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 <map>
#include <vector>
-#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<moduleid_t, module_param*> 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<moduleid_t>* 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<module*>::iterator it1, std::vector<module*>::iterator it2); ///< Swaps two modules positions by their vector iterators
bool find_module(moduleid_t tID, std::vector<module*>::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