Index: ext/libicpf/src/module.h =================================================================== diff -u -r2446443341715955423610c01b43fe7841a10e3e -re553b1c870c6974c1bbab69390b6e720eaf89e55 --- ext/libicpf/src/module.h (.../module.h) (revision 2446443341715955423610c01b43fe7841a10e3e) +++ ext/libicpf/src/module.h (.../module.h) (revision e553b1c870c6974c1bbab69390b6e720eaf89e55) @@ -25,13 +25,13 @@ #define __MODULE_H__ #include "libicpf.h" -#include "mutex.h" +#include "gen_types.h" +/*#include "mutex.h" #include "cfg.h" #include "log.h" #include "file.h" #include #include -#include "gen_types.h" // inclusion of dirent.h #if HAVE_DIRENT_H @@ -55,9 +55,9 @@ /// File extension to use with modules #define MODULE_EXT "" #endif - +*/ BEGIN_ICPF_NAMESPACE - +/* /// NULL module ID #define NULL_MODULE 0x00000000 @@ -80,7 +80,7 @@ * subsequent call to init() and uninit() functions in the external module even if they * will be called more than once in a program. */ -#define MF_INITIALIZED 0x00000002 +/*#define MF_INITIALIZED 0x00000002 /// Type describes the module id. typedef ulonglong_t moduleid_t; @@ -94,7 +94,7 @@ * \param[in] type - module type(could be a bitmask) - only the lower 28 bits will be used * \param[in] unique_id - 32-bit unique id (should be randomly generated) */ -#define MAKE_MODID(internal,type,unique_id)\ +/*#define MAKE_MODID(internal,type,unique_id)\ ((internal ? 0ULL : 0x8000000000000000ULL) | (((ulonglong_t)type & 0x0fffffff) << 32) | unique_id) /** \brief Class for managing the parameters of a module. @@ -103,39 +103,39 @@ * module destruction) to store module settings to a file or to configuration. * \todo This class needs some more clarification - how to use it, the purpose, ... */ -class LIBICPF_API module_param +/*class LIBICPF_API module_param { public: /** \name Construction/destruction */ /**@{*/ - module_param(); ///< Standard constructor +/* module_param(); ///< Standard constructor virtual ~module_param(); ///< Standard destructor /**@}*/ /** \name Locking/unlocking */ /**@{*/ - void lock(); ///< Locks the class (gets exclusive ownership of this object) +/* void lock(); ///< Locks the class (gets exclusive ownership of this object) void unlock(); ///< Unlocks the class (releases the ownership) /**@}*/ /** \name Informations */ /**@*/ - moduleid_t get_moduleid() const; ///< Returns a module id associated with this class +/* moduleid_t get_moduleid() const; ///< Returns a module id associated with this class /**@}*/ /** \name Configuration support */ /**@{*/ - virtual void read_config(config* pcfg); ///< Reads the configuration properties from a config object +/* virtual void read_config(config* pcfg); ///< Reads the configuration properties from a config object virtual void write_config(config* pcfg); ///< Writes the internal properties to the config object virtual void register_properties(config* pcfg); ///< Registers properties for use with the config object /**@}*/ /** \name Serialization support */ /**@{*/ - virtual void store(file& ser); ///< Stores the internal properties in the serialization object (file) +/* virtual void store(file& ser); ///< Stores the internal properties in the serialization object (file) virtual void load(file& ser); ///< Loads the internal properties from a serialization object (file) /**@}*/ - +/* protected: moduleid_t m_midModuleID; ///< ID of a module that owns this parameters uint_t m_uiPropStart; ///< ID of the first registered property (see register_properties()) @@ -147,36 +147,36 @@ * Class handles the management of lists of module_param classes. One module can have only * one module_param (or derived) class associated with it. */ -class LIBICPF_API modparam_list +/*class LIBICPF_API modparam_list { public: /** \name Construction/destruction */ /**@{*/ - modparam_list(); ///< Standard constructor +/* modparam_list(); ///< Standard constructor ~modparam_list(); ///< Standard destructor /**@}*/ /** \name Standard operations */ /**@{*/ - void insert(module_param* pEntry); ///< Inserts a new module_param to this container +/* void insert(module_param* pEntry); ///< Inserts a new module_param to this container bool remove(moduleid_t tEntry, bool bDelete=true); ///< Removes a module_param associated with a given module id void clear(bool bDelete=true); ///< Removes all the entries from the list module_param* find(moduleid_t mid); ///< Searches for a module_param associated with a given module id /**@}*/ /** \name Configuration support */ /**@{*/ - void read_config(config* pcfg); ///< Reads the configuration properties from a config object +/* void read_config(config* pcfg); ///< Reads the configuration properties from a config object void write_config(config* pcfg); ///< Writes the internal properties to the config object void register_properties(config* pcfg); ///< Registers properties for use with the config object /**@}*/ /** \name Serialization support */ /**@{*/ - void store(file& ser); ///< Stores the internal properties in the serialization object (file) +/* void store(file& ser); ///< Stores the internal properties in the serialization object (file) void load(file& ser); ///< Loads the internal properties from a serialization object (file) /**@}*/ - +/* protected: void* m_pMods; ///< Internal map of module parameters // std::map m_mMods; @@ -188,7 +188,7 @@ * Structure contains some fields used to identify a module (module name, * id, type, author information and so on). */ -struct MODULE_INFO +/*struct MODULE_INFO { uint_t uiInfoLen; ///< Count of bytes contained in this struct (filled by plugin) char_t szAuthor[128]; ///< Author's full name @@ -203,7 +203,7 @@ * Structure contains init parameters passed into the constructor and * the init() function of a module and module_list class. */ -struct MODULE_INITDATA +/*struct MODULE_INITDATA { config *pcfg; ///< Global configuration object log_file *plog; ///< Log file object to perform logging to @@ -239,7 +239,7 @@ * \param[in] fn_name - string with the function name to get addres of * \note Macro throws an exception if the export cannot be loaded. */ - #define MAP_EXPORT(module,var,fn_name)\ +/* #define MAP_EXPORT(module,var,fn_name)\ (FARPROC&)var=::GetProcAddress(module, fn_name);\ if (var == NULL)\ THROW(exception::format("Cannot load an export " STRFMT " from the external module (handle " PTRFMT ")", fn_name, module), PE_CALLNOTIMPLEMENTED, GetLastError(), 0); @@ -253,7 +253,7 @@ * \param[in] fn_name - string with the function name to get addres of * \note Macro throws an exception if the export cannot be loaded. */ - #define MAP_EXPORT(module,var,fn_name)\ +/* #define MAP_EXPORT(module,var,fn_name)\ *((ptr_t*)&var)=dlsym(module, fn_name);\ if (var == NULL)\ THROW(exception::format("Cannot load an export " STRFMT " from the external module - " STRFMT " (handle " PTRFMT ")", fn_name, dlerror(), module), PE_CALLNOTIMPLEMENTED, 0, 0); @@ -265,24 +265,24 @@ * from which should be derived any other module classes that handle different types * of modules. */ -class LIBICPF_API module +/*class LIBICPF_API module { public: /** \name Construction/destruction */ /**@{*/ - module(const MODULE_INITDATA* pData, uint_t uiFlags=MF_EXTERNAL); ///< Standard constructor +/* module(const MODULE_INITDATA* pData, uint_t uiFlags=MF_EXTERNAL); ///< Standard constructor virtual ~module(); ///< Standard destructor /**@}*/ /** \name External modules support */ /**@{*/ - void open(const char_t* pszPath); ///< Opens an external module (file) +/* void open(const char_t* pszPath); ///< Opens an external module (file) void close(bool bFullDestruct=false); ///< Closes an external module (uninitializes if needed) /**@}*/ /** \name Module information */ /**@{*/ - /// Retrieves the module information directly from the module +/* /// Retrieves the module information directly from the module void get_info(MODULE_INFO* pInfo); /// Returns an address of the cached module information structure const MODULE_INFO* get_info() { return &m_mi; }; @@ -300,27 +300,27 @@ /** \name Module parameters */ /**@{*/ - virtual module_param* alloc_modparam(); ///< Allocates a module_param (or derived) class - should be overloaded. +/* virtual module_param* alloc_modparam(); ///< Allocates a module_param (or derived) class - should be overloaded. /**@}*/ /** \name Initialization/uninitialization */ /**@{*/ - virtual bool init(const MODULE_INITDATA* pData); ///< Initializes the module (if not initialized yet) +/* virtual bool init(const MODULE_INITDATA* pData); ///< Initializes the module (if not initialized yet) virtual bool uninit(); ///< Uninitializes the module (if not uninitialized yet) /**@}*/ /** \name Reference counting */ /**@{*/ - /// Retrieves the current reference count +/* /// Retrieves the current reference count int_t get_refcount() const { return m_lRefCount; }; /// Increases the reference count void acquire() { ++m_lRefCount; }; /// Decreases the reference count int_t release() { return --m_lRefCount; }; /**@}*/ -protected: - /// Loads all needed exports from an external module +//protected: +/* /// Loads all needed exports from an external module virtual void load_exports(); /// Cleans up the internal stuff @@ -350,18 +350,18 @@ * a basic operations on a list of modules (searching, inserting, removing, ...). * Should be a base for any module management class. */ -class LIBICPF_API module_list +/*class LIBICPF_API module_list { public: /** \name Construction/destruction */ /**@{*/ - module_list(const MODULE_INITDATA* pData); ///< Standard constructor +/* module_list(const MODULE_INITDATA* pData); ///< Standard constructor ~module_list(); ///< Standard destructor /**@}*/ /** \name Adding/removing */ /**@{*/ - void scan(const char_t* pszPath, uint_t uiType=MT_ALL); ///< Scans a directory for some modules +/* void scan(const char_t* pszPath, uint_t uiType=MT_ALL); ///< Scans a directory for some modules // adding a new items (modules) void insert(size_t tPos, module* tModule); ///< Inserts a module at a specified position @@ -376,13 +376,13 @@ /** \name Searching */ /**@{*/ - module* find(moduleid_t mid); ///< Searches a list for the module with the specified ID +/* module* find(moduleid_t mid); ///< Searches a list for the module with the specified ID module* at(size_t tPos); ///< Gets the module at a specified position on the list /**@}*/ /** \name Module repositioning */ /**@{*/ - void swap(moduleid_t t1, moduleid_t t2); ///< Swaps two modules positions by their ID's +/* void swap(moduleid_t t1, moduleid_t t2); ///< Swaps two modules positions by their ID's void swap(size_t tPos1, size_t tPos2); ///< Swaps two modules positions by their positions void move(moduleid_t tID, size_t tNewPos); ///< Moves the specified module to a new position void sort(std::vector* vIDs); ///< Sorts the modules using a module id vector @@ -391,9 +391,9 @@ /** \name Other */ /**@{*/ - size_t size(); ///< Retrieves a count of modules in a list +/* size_t size(); ///< Retrieves a count of modules in a list /**@}*/ - +/* protected: void swap(std::vector::iterator it1, std::vector::iterator it2); ///< Swaps two modules positions by their vector iterators bool find_module(moduleid_t tID, std::vector::iterator* pit); ///< Searches for the module by it's ID and returns an iterator @@ -413,7 +413,7 @@ mutex m_lock; ///< Thread-safe access guarantee }; - +*/ END_ICPF_NAMESPACE #endif