2004-05-22 00:05:20 +00:00
|
|
|
/**
|
2005-03-18 18:16:59 +00:00
|
|
|
* yatengine.h
|
2004-05-22 00:05:20 +00:00
|
|
|
* This file is part of the YATE Project http://YATE.null.ro
|
2004-11-29 03:56:41 +00:00
|
|
|
*
|
|
|
|
* Yet Another Telephony Engine - a fully featured software PBX and IVR
|
|
|
|
* Copyright (C) 2004 Null Team
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2004-11-29 03:56:41 +00:00
|
|
|
|
2005-03-18 18:16:59 +00:00
|
|
|
#ifndef __YATENGINE_H
|
|
|
|
#define __YATENGINE_H
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
#ifndef __cplusplus
|
|
|
|
#error C++ is required
|
|
|
|
#endif
|
|
|
|
|
2004-12-08 00:04:26 +00:00
|
|
|
#include <stddef.h>
|
2005-04-02 13:28:14 +00:00
|
|
|
#include <sys/types.h>
|
2004-12-08 00:04:26 +00:00
|
|
|
|
2005-04-02 00:49:38 +00:00
|
|
|
#ifndef _WINDOWS
|
|
|
|
#ifdef WIN32
|
|
|
|
#define _WINDOWS
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef _WINDOWS
|
2005-04-02 13:28:14 +00:00
|
|
|
|
2005-04-02 00:49:38 +00:00
|
|
|
typedef signed __int32 int32_t;
|
|
|
|
typedef unsigned __int32 u_int32_t;
|
|
|
|
typedef signed __int64 int64_t;
|
|
|
|
typedef unsigned __int64 u_int64_t;
|
|
|
|
|
|
|
|
#define vsnprintf _vsnprintf
|
|
|
|
#define snprintf _snprintf
|
|
|
|
#define strcasecmp _stricmp
|
|
|
|
#define strdup _strdup
|
|
|
|
#define random rand
|
|
|
|
|
|
|
|
#ifdef LIBYATE_EXPORTS
|
|
|
|
#define YATE_API __declspec(dllexport)
|
|
|
|
#else
|
|
|
|
#define YATE_API __declspec(dllimport)
|
|
|
|
#endif
|
|
|
|
|
2005-04-02 13:28:14 +00:00
|
|
|
#else /* _WINDOWS */
|
2005-04-02 00:49:38 +00:00
|
|
|
|
|
|
|
#define YATE_API
|
|
|
|
|
2005-04-02 13:28:14 +00:00
|
|
|
#endif /* ! _WINDOWS */
|
2005-04-02 00:49:38 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
struct timeval;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Holds all Telephony Engine related classes.
|
|
|
|
*/
|
|
|
|
namespace TelEngine {
|
|
|
|
|
2004-09-11 10:43:49 +00:00
|
|
|
#ifdef HAVE_GCC_FORMAT_CHECK
|
|
|
|
#define FORMAT_CHECK(f) __attribute__((format(printf,(f),(f)+1)))
|
|
|
|
#else
|
|
|
|
#define FORMAT_CHECK(f)
|
|
|
|
#endif
|
|
|
|
|
2004-10-14 16:36:24 +00:00
|
|
|
/**
|
|
|
|
* Abort execution (and coredump if allowed) if the abort flag is set.
|
|
|
|
* This function may not return.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API void abortOnBug();
|
2004-10-14 16:36:24 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the abort on bug flag. The default flag state is false.
|
|
|
|
* @return The old state of the flag.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API bool abortOnBug(bool doAbort);
|
2004-10-14 16:36:24 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Standard debugging levels.
|
2004-12-08 00:04:26 +00:00
|
|
|
* The DebugFail level is special - it is always displayed and may abort
|
|
|
|
* the program if @ref abortOnBug() is set.
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
|
|
|
enum DebugLevel {
|
|
|
|
DebugFail = 0,
|
|
|
|
DebugGoOn = 2,
|
|
|
|
DebugWarn = 5,
|
|
|
|
DebugMild = 7,
|
|
|
|
DebugInfo = 9,
|
|
|
|
DebugAll = 10
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2005-03-20 03:11:53 +00:00
|
|
|
* Retrive the current global debug level
|
|
|
|
* @return The current global debug level
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API int debugLevel();
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
2005-03-20 03:11:53 +00:00
|
|
|
* Set the current global debug level.
|
2004-05-22 00:05:20 +00:00
|
|
|
* @param level The desired debug level
|
2005-03-20 03:11:53 +00:00
|
|
|
* @return The new global debug level (may be different)
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API int debugLevel(int level);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if debugging output should be generated
|
2005-03-20 03:11:53 +00:00
|
|
|
* @param level The global debug level we are testing
|
2004-05-22 00:05:20 +00:00
|
|
|
* @return True if messages should be output, false otherwise
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API bool debugAt(int level);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2005-03-20 03:11:53 +00:00
|
|
|
/**
|
|
|
|
* Holds a local debugging level that can be modified separately from the
|
|
|
|
* global debugging
|
|
|
|
* @short A holder for a debug level
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API DebugEnabler
|
2005-03-20 03:11:53 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Constructor
|
2005-03-28 22:27:26 +00:00
|
|
|
* @param level The initial local debug level
|
2005-03-20 03:11:53 +00:00
|
|
|
*/
|
2005-03-28 22:27:26 +00:00
|
|
|
inline DebugEnabler(int level = TelEngine::debugLevel(), bool enabled = true)
|
|
|
|
: m_level(DebugFail), m_enabled(enabled), m_chain(0)
|
2005-03-20 03:11:53 +00:00
|
|
|
{ debugLevel(level); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the current local debug level
|
|
|
|
* @return The current local debug level
|
|
|
|
*/
|
|
|
|
inline int debugLevel() const
|
2005-03-28 22:27:26 +00:00
|
|
|
{ return m_chain ? m_chain->debugLevel() : m_level; }
|
2005-03-20 03:11:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the current local debug level.
|
|
|
|
* @param level The desired debug level
|
|
|
|
* @return The new debug level (may be different)
|
|
|
|
*/
|
|
|
|
int debugLevel(int level);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the current debug activation status
|
|
|
|
* @return True if local debugging is enabled
|
|
|
|
*/
|
|
|
|
inline bool debugEnabled() const
|
2005-03-28 22:27:26 +00:00
|
|
|
{ return m_chain ? m_chain->debugEnabled() : m_enabled; }
|
2005-03-20 03:11:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the current debug activation status
|
|
|
|
* @param enable The new debug activation status, true to enable
|
|
|
|
*/
|
|
|
|
inline void debugEnabled(bool enable)
|
2005-03-28 22:27:26 +00:00
|
|
|
{ m_enabled = enable; m_chain = 0; }
|
2005-03-20 03:11:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if debugging output should be generated
|
|
|
|
* @param level The debug level we are testing
|
|
|
|
* @return True if messages should be output, false otherwise
|
|
|
|
*/
|
2005-03-28 22:27:26 +00:00
|
|
|
bool debugAt(int level) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Chain this debug holder to a parent or detach from existing one
|
|
|
|
* @param chain Pointer to parent debug level, NULL to detach
|
|
|
|
*/
|
|
|
|
inline void debugChain(DebugEnabler* chain = 0)
|
|
|
|
{ m_chain = (chain != this) ? chain : 0; }
|
2005-03-20 03:11:53 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
int m_level;
|
|
|
|
bool m_enabled;
|
2005-03-28 22:27:26 +00:00
|
|
|
DebugEnabler* m_chain;
|
2005-03-20 03:11:53 +00:00
|
|
|
};
|
|
|
|
|
2004-11-29 21:01:04 +00:00
|
|
|
#if 0
|
|
|
|
/**
|
|
|
|
* Convenience macro.
|
|
|
|
* Does the same as @ref Debug if DEBUG is #defined (compiling for debugging)
|
|
|
|
* else it does not get compiled at all.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool DDebug(int level, const char* format, ...);
|
2004-11-29 21:01:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convenience macro.
|
|
|
|
* Does the same as @ref Debug if DEBUG is #defined (compiling for debugging)
|
|
|
|
* else it does not get compiled at all.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool DDebug(const char* facility, int level, const char* format, ...);
|
2004-11-29 21:01:04 +00:00
|
|
|
|
2005-01-27 21:26:00 +00:00
|
|
|
/**
|
|
|
|
* Convenience macro.
|
|
|
|
* Does the same as @ref Debug if XDEBUG is #defined (compiling for extra
|
|
|
|
* debugging) else it does not get compiled at all.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool XDebug(int level, const char* format, ...);
|
2005-01-27 21:26:00 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convenience macro.
|
|
|
|
* Does the same as @ref Debug if XDEBUG is #defined (compiling for extra
|
|
|
|
* debugging) else it does not get compiled at all.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool XDebug(const char* facility, int level, const char* format, ...);
|
2005-01-27 21:26:00 +00:00
|
|
|
|
2004-11-29 21:01:04 +00:00
|
|
|
/**
|
|
|
|
* Convenience macro.
|
2004-11-29 21:15:59 +00:00
|
|
|
* Does the same as @ref Debug if NDEBUG is not #defined
|
|
|
|
* else it does not get compiled at all (compiling for mature release).
|
2004-11-29 21:01:04 +00:00
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool NDebug(int level, const char* format, ...);
|
2004-11-29 21:01:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convenience macro.
|
2004-11-29 21:15:59 +00:00
|
|
|
* Does the same as @ref Debug if NDEBUG is not #defined
|
|
|
|
* else it does not get compiled at all (compiling for mature release).
|
2004-11-29 21:01:04 +00:00
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool NDebug(const char* facility, int level, const char* format, ...);
|
2004-11-29 21:01:04 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-02 00:49:38 +00:00
|
|
|
#ifdef _DEBUG
|
|
|
|
#undef DEBUG
|
|
|
|
#define DEBUG
|
|
|
|
#endif
|
|
|
|
|
2005-01-27 21:26:00 +00:00
|
|
|
#ifdef XDEBUG
|
|
|
|
#undef DEBUG
|
|
|
|
#define DEBUG
|
|
|
|
#endif
|
|
|
|
|
2004-11-29 21:01:04 +00:00
|
|
|
#ifdef DEBUG
|
2005-04-02 00:49:38 +00:00
|
|
|
#define DDebug Debug
|
|
|
|
#else
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
#define DDebug
|
2004-11-29 21:01:04 +00:00
|
|
|
#else
|
|
|
|
#define DDebug(arg...)
|
|
|
|
#endif
|
2005-04-02 00:49:38 +00:00
|
|
|
#endif
|
2004-11-29 21:01:04 +00:00
|
|
|
|
2005-01-27 21:26:00 +00:00
|
|
|
#ifdef XDEBUG
|
2005-04-02 00:49:38 +00:00
|
|
|
#define XDebug Debug
|
|
|
|
#else
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
#define XDebug
|
2005-01-27 21:26:00 +00:00
|
|
|
#else
|
|
|
|
#define XDebug(arg...)
|
|
|
|
#endif
|
2005-04-02 00:49:38 +00:00
|
|
|
#endif
|
2005-01-27 21:26:00 +00:00
|
|
|
|
2004-11-29 21:01:04 +00:00
|
|
|
#ifndef NDEBUG
|
2005-04-02 00:49:38 +00:00
|
|
|
#define NDebug Debug
|
|
|
|
#else
|
|
|
|
#ifdef _WINDOWS
|
|
|
|
#define NDebug
|
2004-11-29 21:01:04 +00:00
|
|
|
#else
|
|
|
|
#define NDebug(arg...)
|
|
|
|
#endif
|
2005-04-02 00:49:38 +00:00
|
|
|
#endif
|
2004-11-29 21:01:04 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Outputs a debug string.
|
|
|
|
* @param level The level of the message
|
|
|
|
* @param format A printf() style format string
|
|
|
|
* @return True if message was output, false otherwise
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API bool Debug(int level, const char* format, ...) FORMAT_CHECK(2);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Outputs a debug string for a specific facility.
|
|
|
|
* @param facility Facility that outputs the message
|
|
|
|
* @param level The level of the message
|
|
|
|
* @param format A printf() style format string
|
|
|
|
* @return True if message was output, false otherwise
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API bool Debug(const char* facility, int level, const char* format, ...) FORMAT_CHECK(3);
|
2005-03-20 03:11:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Outputs a debug string for a specific facility.
|
|
|
|
* @param local Pointer to a DebugEnabler holding current debugging settings
|
|
|
|
* @param level The level of the message
|
|
|
|
* @param format A printf() style format string
|
|
|
|
* @return True if message was output, false otherwise
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API bool Debug(const DebugEnabler* local, int level, const char* format, ...) FORMAT_CHECK(3);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Outputs a string to the debug console with formatting
|
|
|
|
* @param facility Facility that outputs the message
|
|
|
|
* @param format A printf() style format string
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API void Output(const char* format, ...) FORMAT_CHECK(1);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
2004-12-04 15:44:54 +00:00
|
|
|
* This class is used as an automatic variable that logs messages on creation
|
2005-03-20 03:11:53 +00:00
|
|
|
* and destruction (when the instruction block is left or function returns).
|
|
|
|
* IMPORTANT: the name is not copied so it should best be static.
|
2004-12-04 15:44:54 +00:00
|
|
|
* @short An object that logs messages on creation and destruction
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Debugger
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* The constructor prints the method entry message and indents.
|
|
|
|
* @param name Name of the function or block entered, must be static
|
|
|
|
* @param format printf() style format string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Debugger(const char* name, const char* format = 0, ...);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The constructor prints the method entry message and indents.
|
|
|
|
* @param level The level of the message
|
|
|
|
* @param name Name of the function or block entered, must be static
|
|
|
|
* @param format printf() style format string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Debugger(int level, const char* name, const char* format = 0, ...);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The destructor prints the method leave message and deindents.
|
|
|
|
*/
|
|
|
|
~Debugger();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the output callback
|
|
|
|
* @param outFunc Pointer to the output function, NULL to use stderr
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static void setOutput(void (*outFunc)(const char*) = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the interactive output callback
|
|
|
|
* @param outFunc Pointer to the output function, NULL to disable
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static void setIntOut(void (*outFunc)(const char*) = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Enable or disable the debug output
|
|
|
|
*/
|
|
|
|
static void enableOutput(bool enable = true);
|
|
|
|
|
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
const char* m_name;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A structure to build (mainly static) Token-to-ID translation tables.
|
|
|
|
* A table of such structures must end with an entry with a null token
|
|
|
|
*/
|
2004-11-29 21:15:59 +00:00
|
|
|
struct TokenDict {
|
2005-03-20 03:11:53 +00:00
|
|
|
const char* token;
|
2004-05-22 00:05:20 +00:00
|
|
|
int value;
|
2004-11-29 21:15:59 +00:00
|
|
|
};
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2004-12-04 15:44:54 +00:00
|
|
|
class String;
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* An object with just a public virtual destructor
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Destructor.
|
|
|
|
*/
|
|
|
|
virtual ~GenObject() { }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroys the object, disposes the memory.
|
|
|
|
*/
|
|
|
|
virtual void destruct()
|
|
|
|
{ delete this; }
|
2004-12-04 15:44:54 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a string representation of this object
|
|
|
|
* @return A reference to a String representing this object
|
|
|
|
* which is either null, the object itself (for objects derived from
|
|
|
|
* String) or some form of identification
|
|
|
|
*/
|
|
|
|
virtual const String& toString() const;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A reference counted object.
|
|
|
|
* Whenever using multiple inheritance you should inherit this class virtually.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API RefObject : public GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* The constructor initializes the reference counter to 1!
|
|
|
|
* Use deref() to destruct the object when safe
|
|
|
|
*/
|
|
|
|
RefObject()
|
|
|
|
: m_refcount(1) { }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destructor.
|
|
|
|
*/
|
|
|
|
virtual ~RefObject();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Increments the reference counter
|
|
|
|
* @return The new reference count
|
|
|
|
*/
|
2004-12-20 04:11:29 +00:00
|
|
|
int ref();
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Decrements the reference counter, destroys the object if it reaches zero
|
|
|
|
* <pre>
|
|
|
|
* // Deref this object, return quickly if the object was deleted
|
|
|
|
* if (deref()) return;
|
|
|
|
* </pre>
|
|
|
|
* @return True if the object was deleted, false if it still exists
|
|
|
|
*/
|
2004-12-20 04:11:29 +00:00
|
|
|
bool deref();
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the current value of the reference counter
|
|
|
|
* @return The value of the reference counter
|
|
|
|
*/
|
|
|
|
inline int refcount() const
|
|
|
|
{ return m_refcount; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Refcounted objects should just have the counter decremented.
|
|
|
|
* That will destroy them only when the refcount reaches zero.
|
|
|
|
*/
|
|
|
|
virtual void destruct()
|
|
|
|
{ deref(); }
|
|
|
|
|
|
|
|
private:
|
|
|
|
int m_refcount;
|
|
|
|
};
|
|
|
|
|
2005-03-28 00:58:26 +00:00
|
|
|
/**
|
|
|
|
* Internal helper class providing a non-inline method to RefPointer.
|
|
|
|
* Please don't use this class directly, use @ref RefPointer instead.
|
|
|
|
* @short Internal helper class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API RefPointerBase
|
2005-03-28 00:58:26 +00:00
|
|
|
{
|
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Default constructor, initialize to null pointer
|
|
|
|
*/
|
|
|
|
inline RefPointerBase()
|
|
|
|
: m_pointer(0) { }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a new stored pointer
|
|
|
|
* @param oldptr Pointer to the RefObject of the old stored object
|
|
|
|
* @param newptr Pointer to the RefObject of the new stored object
|
|
|
|
* @param pointer A void pointer to the derived class
|
|
|
|
*/
|
|
|
|
void assign(RefObject* oldptr, RefObject* newptr, void* pointer);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The untyped stored pointer that should be casted to a @ref RefObject derived class
|
|
|
|
*/
|
|
|
|
void* m_pointer;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @short Templated smart pointer class
|
|
|
|
*/
|
|
|
|
template <class Obj = RefObject> class RefPointer : public RefPointerBase
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Retrive the stored pointer
|
|
|
|
* @return A typed pointer
|
|
|
|
*/
|
|
|
|
inline Obj* pointer() const
|
|
|
|
{ return static_cast<Obj*>(m_pointer); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a new stored pointer
|
|
|
|
* @param object Pointer to the new stored object
|
|
|
|
*/
|
|
|
|
void assign(Obj* object = 0)
|
2005-03-28 22:27:26 +00:00
|
|
|
{ RefPointerBase::assign(pointer(),object,object); }
|
2005-03-28 00:58:26 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Default constructor - creates a null smart pointer
|
|
|
|
*/
|
|
|
|
inline RefPointer()
|
|
|
|
{ }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy constructor, references the object
|
|
|
|
* @param value Original RefPointer
|
|
|
|
*/
|
|
|
|
inline RefPointer(const RefPointer<Obj>& value)
|
|
|
|
{ assign(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Constructs an initialized smart pointer, references the object
|
|
|
|
* @param object Pointer to object
|
|
|
|
*/
|
|
|
|
inline RefPointer(Obj* object)
|
|
|
|
{ assign(object); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destructs the pointer and dereferences the object
|
|
|
|
*/
|
|
|
|
inline ~RefPointer()
|
|
|
|
{ assign(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment from smart pointer
|
|
|
|
*/
|
|
|
|
inline RefPointer<Obj>& operator=(const RefPointer<Obj>& value)
|
|
|
|
{ assign(const_cast<const Obj*>(value)); return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment from regular pointer
|
|
|
|
*/
|
|
|
|
inline RefPointer<Obj>& operator=(Obj* object)
|
|
|
|
{ assign(object); return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Conversion to regular pointer operator
|
|
|
|
* @return The stored pointer
|
|
|
|
*/
|
|
|
|
inline operator Obj*() const
|
|
|
|
{ return pointer(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Member access operator
|
|
|
|
*/
|
|
|
|
inline Obj* operator->()
|
|
|
|
{ return pointer(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Dereferencing operator
|
|
|
|
*/
|
|
|
|
inline Obj& operator*()
|
|
|
|
{ return *pointer(); }
|
|
|
|
};
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* A simple single-linked object list handling class
|
|
|
|
* @short An object list class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API ObjList : public GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new, empty list.
|
|
|
|
*/
|
|
|
|
ObjList();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroys the list and everything in it.
|
|
|
|
*/
|
|
|
|
virtual ~ObjList();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of elements in the list
|
|
|
|
* @return Count of items
|
|
|
|
*/
|
|
|
|
unsigned int length() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of non-null objects in the list
|
|
|
|
* @return Count of items
|
|
|
|
*/
|
|
|
|
unsigned int count() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the object associated to this list item
|
|
|
|
* @return Pointer to the object or NULL
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline GenObject* get() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_obj; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the object associated to this list item
|
|
|
|
* @param obj Pointer to the new object to set
|
|
|
|
* @param delold True to delete the old object (default)
|
|
|
|
* @return Pointer to the old object if not destroyed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
GenObject* set(const GenObject* obj, bool delold = true);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the next item in the list
|
|
|
|
* @return Pointer to the next item in list or NULL
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline ObjList* next() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_next; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the last item in the list
|
|
|
|
* @return Pointer to the last item in list
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
ObjList* last() const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
2005-03-20 03:11:53 +00:00
|
|
|
* Pointer-like indexing operator
|
|
|
|
* @param index Index of the list item to retrive
|
|
|
|
* @return Pointer to the list item or NULL
|
|
|
|
*/
|
|
|
|
ObjList* operator+(int index) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Array-like indexing operator
|
|
|
|
* @param index Index of the object to retrive
|
|
|
|
* @return Pointer to the object or NULL
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
GenObject* operator[](int index) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the item in the list that holds an object
|
|
|
|
* @param obj Pointer to the object to search for
|
|
|
|
* @return Pointer to the found item or NULL
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
ObjList* find(const GenObject* obj) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2004-12-04 15:44:54 +00:00
|
|
|
/**
|
|
|
|
* Get the item in the list that holds an object by String value
|
|
|
|
* @param str String value (toString) of the object to search for
|
|
|
|
* @return Pointer to the found item or NULL
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
ObjList* find(const String& str) const;
|
2004-12-04 15:44:54 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Insert an object at this point
|
|
|
|
* @param obj Pointer to the object to insert
|
|
|
|
* @return A pointer to the inserted list item
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
ObjList* insert(const GenObject* obj);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Append an object to the end of the list
|
|
|
|
* @param obj Pointer to the object to append
|
|
|
|
* @return A pointer to the inserted list item
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
ObjList* append(const GenObject* obj);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete this list item
|
|
|
|
* @param delold True to delete the object (default)
|
|
|
|
* @return Pointer to the object if not destroyed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
GenObject* remove(bool delobj = true);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Delete the list item that holds a given object
|
|
|
|
* @param obj Object to search in the list
|
|
|
|
* @param delobj True to delete the object (default)
|
|
|
|
* @return Pointer to the object if not destroyed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
GenObject* remove(GenObject* obj, bool delobj = true);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear the list and optionally delete all contained objects
|
|
|
|
*/
|
|
|
|
void clear();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the automatic delete flag
|
|
|
|
* @return True if will delete on destruct, false otherwise
|
|
|
|
*/
|
|
|
|
inline bool autoDelete()
|
|
|
|
{ return m_delete; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the automatic delete flag
|
|
|
|
* @param autodelete True to delete on destruct, false otherwise
|
|
|
|
*/
|
|
|
|
inline void setDelete(bool autodelete)
|
|
|
|
{ m_delete = autodelete; }
|
|
|
|
|
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
ObjList* m_next;
|
|
|
|
GenObject* m_obj;
|
2004-05-22 00:05:20 +00:00
|
|
|
bool m_delete;
|
|
|
|
};
|
|
|
|
|
|
|
|
class Regexp;
|
|
|
|
class StringMatchPrivate;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A simple string handling class for C style (one byte) strings.
|
|
|
|
* For simplicity and read speed no copy-on-write is performed.
|
|
|
|
* Strings have hash capabilities and comparations are using the hash
|
|
|
|
* for fast inequality check.
|
|
|
|
* @short A C-style string handling class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API String : public GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new, empty string.
|
|
|
|
*/
|
|
|
|
String();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new initialized string.
|
|
|
|
* @param value Initial value of the string
|
|
|
|
* @param len Length of the data to copy, -1 for full string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String(const char* value, int len = -1);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new initialized string.
|
|
|
|
* @param value Character to fill the string
|
|
|
|
* @param repeat How many copies of the character to use
|
|
|
|
*/
|
|
|
|
String(char value, unsigned int repeat = 1);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new initialized string from an integer.
|
|
|
|
* @param value Value to convert to string
|
|
|
|
*/
|
|
|
|
String(int value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new initialized string from an unsigned int.
|
|
|
|
* @param value Value to convert to string
|
|
|
|
*/
|
|
|
|
String(unsigned int value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new initialized string from a boolean.
|
|
|
|
* @param value Value to convert to string
|
|
|
|
*/
|
|
|
|
String(bool value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy constructor.
|
|
|
|
* @param value Initial value of the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String(const String& value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2005-01-04 02:22:43 +00:00
|
|
|
/**
|
|
|
|
* Constructor from String pointer.
|
|
|
|
* @param value Initial value of the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String(const String* value);
|
2005-01-04 02:22:43 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Destroys the string, disposes the memory.
|
|
|
|
*/
|
|
|
|
virtual ~String();
|
|
|
|
|
2004-12-04 15:44:54 +00:00
|
|
|
/**
|
|
|
|
* A static null String
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static const String& empty();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A standard text representation of boolean values
|
|
|
|
* @param value Boolean value to convert
|
|
|
|
* @return Pointer to a text representation of the value
|
|
|
|
*/
|
|
|
|
inline static const char* boolText(bool value)
|
|
|
|
{ return value ? "true" : "false"; }
|
2004-12-04 15:44:54 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Get the value of the stored string.
|
|
|
|
* @return The stored C string which may be NULL.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline const char* c_str() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_string; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a valid non-NULL C string.
|
2005-03-20 03:11:53 +00:00
|
|
|
* @return The stored C string or a static "".
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline const char* safe() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_string ? m_string : ""; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the length of the stored string.
|
|
|
|
* @return The length of the stored string, zero for NULL.
|
|
|
|
*/
|
|
|
|
inline unsigned int length() const
|
|
|
|
{ return m_length; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the string holds a NULL pointer.
|
|
|
|
* @return True if the string holds NULL, false otherwise.
|
|
|
|
*/
|
|
|
|
inline bool null() const
|
|
|
|
{ return !m_string; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the hash of the contained string.
|
|
|
|
* @return The hash of the string.
|
|
|
|
*/
|
|
|
|
unsigned int hash() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the hash of an arbitrary string.
|
|
|
|
* @return The hash of the string.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static unsigned int hash(const char* value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear the string and free the memory
|
|
|
|
*/
|
|
|
|
void clear();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Extract the caracter at a given index
|
|
|
|
* @param index Index of character in string
|
|
|
|
* @return Character at given index or 0 if out of range
|
|
|
|
*/
|
|
|
|
char at(int index) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Substring extraction
|
|
|
|
* @param offs Offset of the substring, negative to count from end
|
|
|
|
* @param len Length of the substring, -1 for everything possible
|
|
|
|
* @return A copy of the requested substring
|
|
|
|
*/
|
|
|
|
String substr(int offs, int len = -1) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Strip off leading and trailing blank characters
|
|
|
|
*/
|
|
|
|
String& trimBlanks();
|
|
|
|
|
2004-12-04 15:44:54 +00:00
|
|
|
/**
|
|
|
|
* Override GenObject's method to return this String
|
|
|
|
* @return A reference to this String
|
|
|
|
*/
|
|
|
|
virtual const String& toString() const;
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Convert the string to an integer value.
|
|
|
|
* @param defvalue Default to return if the string is not a number
|
|
|
|
* @param base Numeration base, 0 to autodetect
|
|
|
|
* @return The integer interpretation or defvalue.
|
|
|
|
*/
|
|
|
|
int toInteger(int defvalue = 0, int base = 0) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Convert the string to an integer value looking up first a token table.
|
|
|
|
* @param tokens Pointer to an array of tokens to lookup first
|
|
|
|
* @param defvalue Default to return if the string is not a token or number
|
|
|
|
* @param base Numeration base, 0 to autodetect
|
|
|
|
* @return The integer interpretation or defvalue.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
int toInteger(const TokenDict* tokens, int defvalue = 0, int base = 0) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convert the string to a boolean value.
|
|
|
|
* @param defvalue Default to return if the string is not a bool
|
|
|
|
* @return The boolean interpretation or defvalue.
|
|
|
|
*/
|
|
|
|
bool toBoolean(bool defvalue = false) const;
|
|
|
|
|
2004-12-24 03:26:13 +00:00
|
|
|
/**
|
|
|
|
* Turn the string to an all-uppercase string
|
|
|
|
* @return A reference to this String
|
|
|
|
*/
|
|
|
|
String& toUpper();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Turn the string to an all-lowercase string
|
|
|
|
* @return A reference to this String
|
|
|
|
*/
|
|
|
|
String& toLower();
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Indexing operator
|
|
|
|
* @param index Index of character in string
|
|
|
|
* @return Character at given index or 0 if out of range
|
|
|
|
*/
|
|
|
|
inline char operator[](int index) const
|
|
|
|
{ return at(index); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Conversion to "const char *" operator.
|
|
|
|
*/
|
|
|
|
inline operator const char*() const
|
|
|
|
{ return m_string; };
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assigns a new value to the string from a character block.
|
|
|
|
* @param value New value of the string
|
|
|
|
* @param len Length of the data to copy, -1 for full string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& assign(const char* value, int len = -1);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline String& operator=(const String& value)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return operator=(value.c_str()); }
|
|
|
|
|
2005-01-04 02:22:43 +00:00
|
|
|
/**
|
|
|
|
* Assignment from String* operator.
|
|
|
|
* @see TelEngine::strcpy
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline String& operator=(const String* value)
|
2005-01-15 18:34:22 +00:00
|
|
|
{ return operator=(value ? value->c_str() : ""); }
|
2005-01-04 02:22:43 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Assignment from char* operator.
|
|
|
|
* @see TelEngine::strcpy
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator=(const char* value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator for single characters.
|
|
|
|
*/
|
|
|
|
String& operator=(char value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator for integers.
|
|
|
|
*/
|
|
|
|
String& operator=(int value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator for unsigned integers.
|
|
|
|
*/
|
|
|
|
String& operator=(unsigned int value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator for booleans.
|
|
|
|
*/
|
|
|
|
inline String& operator=(bool value)
|
2005-03-20 03:11:53 +00:00
|
|
|
{ return operator=(boolText(value)); }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Appending operator for strings.
|
|
|
|
* @see TelEngine::strcat
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator+=(const char* value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Appending operator for single characters.
|
|
|
|
*/
|
|
|
|
String& operator+=(char value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Appending operator for integers.
|
|
|
|
*/
|
|
|
|
String& operator+=(int value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Appending operator for unsigned integers.
|
|
|
|
*/
|
|
|
|
String& operator+=(unsigned int value);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Appending operator for booleans.
|
|
|
|
*/
|
|
|
|
inline String& operator+=(bool value)
|
2005-03-20 03:11:53 +00:00
|
|
|
{ return operator+=(boolText(value)); }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Equality operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool operator==(const char* value) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Inequality operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool operator!=(const char* value) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Fast equality operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool operator==(const String& value) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Fast inequality operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool operator!=(const String& value) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2004-12-27 15:08:12 +00:00
|
|
|
/**
|
|
|
|
* Case-insensitive equality operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool operator&=(const char* value) const;
|
2004-12-27 15:08:12 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Case-insensitive inequality operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool operator|=(const char* value) const;
|
2004-12-27 15:08:12 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Stream style appending operator for C strings
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline String& operator<<(const char* value)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return operator+=(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style appending operator for single characters
|
|
|
|
*/
|
|
|
|
inline String& operator<<(char value)
|
|
|
|
{ return operator+=(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style appending operator for integers
|
|
|
|
*/
|
|
|
|
inline String& operator<<(int value)
|
|
|
|
{ return operator+=(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style appending operator for unsigned integers
|
|
|
|
*/
|
|
|
|
inline String& operator<<(unsigned int value)
|
|
|
|
{ return operator+=(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style appending operator for booleans
|
|
|
|
*/
|
|
|
|
inline String& operator<<(bool value)
|
|
|
|
{ return operator+=(value); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style substring skipping operator.
|
|
|
|
* It eats all characters up to and including the skip string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator>>(const char* skip);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style extraction operator for single characters
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator>>(char& store);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style extraction operator for integers
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator>>(int& store);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style extraction operator for unsigned integers
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator>>(unsigned int& store);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Stream style extraction operator for booleans
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String& operator>>(bool& store);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2005-03-28 00:58:26 +00:00
|
|
|
/**
|
|
|
|
* Conditional appending with a separator
|
|
|
|
* @param value String to append
|
|
|
|
* @param separator Separator to insert before the value
|
|
|
|
* @param force True to allow appending empty strings
|
|
|
|
*/
|
|
|
|
String& append(const char* value, const char* separator = 0, bool force = false);
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Locate the first instance of a character in the string
|
|
|
|
* @param what Character to search for
|
|
|
|
* @param offs Offset in string to start searching from
|
|
|
|
* @return Offset of character or -1 if not found
|
|
|
|
*/
|
|
|
|
int find(char what, unsigned int offs = 0) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Locate the first instance of a substring in the string
|
|
|
|
* @param what Substring to search for
|
|
|
|
* @param offs Offset in string to start searching from
|
|
|
|
* @return Offset of substring or -1 if not found
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
int find(const char* what, unsigned int offs = 0) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Locate the last instance of a character in the string
|
|
|
|
* @param what Character to search for
|
|
|
|
* @return Offset of character or -1 if not found
|
|
|
|
*/
|
|
|
|
int rfind(char what) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the string starts with a substring
|
|
|
|
* @param what Substring to search for
|
|
|
|
* @param wordBreak Check if a word boundary follows the substring
|
|
|
|
* @return True if the substring occurs at the beginning of the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool startsWith(const char* what, bool wordBreak = false) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the string ends with a substring
|
|
|
|
* @param what Substring to search for
|
|
|
|
* @param wordBreak Check if a word boundary precedes the substring
|
|
|
|
* @return True if the substring occurs at the end of the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool endsWith(const char* what, bool wordBreak = false) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2004-12-01 00:54:04 +00:00
|
|
|
/**
|
|
|
|
* Checks if the string starts with a substring and removes it
|
|
|
|
* @param what Substring to search for
|
|
|
|
* @param wordBreak Check if a word boundary follows the substring;
|
|
|
|
* this parameter defaults to True because the intended use of this
|
|
|
|
* method is to separate commands from their parameters
|
|
|
|
* @return True if the substring occurs at the beginning of the string
|
|
|
|
* and also removes the substring; if wordBreak is True any word
|
|
|
|
* breaking characters are also removed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool startSkip(const char* what, bool wordBreak = true);
|
2004-12-01 00:54:04 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Checks if matches another string
|
|
|
|
* @param value String to check for match
|
|
|
|
* @return True if matches, false otherwise
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
virtual bool matches(const String& value) const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return operator==(value); }
|
|
|
|
|
|
|
|
/**
|
2004-12-04 15:44:54 +00:00
|
|
|
* Checks if matches a regular expression and fill the match substrings
|
2004-05-22 00:05:20 +00:00
|
|
|
* @param rexp Regular expression to check for match
|
|
|
|
* @return True if matches, false otherwise
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool matches(Regexp& rexp);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the offset of the last match
|
|
|
|
* @param index Index of the submatch to return, 0 for full match
|
|
|
|
* @return Offset of the last match, -1 if no match or not in range
|
|
|
|
*/
|
|
|
|
int matchOffset(int index = 0) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the length of the last match
|
|
|
|
* @param index Index of the submatch to return, 0 for full match
|
|
|
|
* @return Length of the last match, 0 if no match or out of range
|
|
|
|
*/
|
|
|
|
int matchLength(int index = 0) const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a copy of a matched (sub)string
|
|
|
|
* @param index Index of the submatch to return, 0 for full match
|
|
|
|
* @return Copy of the matched substring
|
|
|
|
*/
|
|
|
|
inline String matchString(int index = 0) const
|
|
|
|
{ return substr(matchOffset(index),matchLength(index)); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a string by replacing matched strings in a template
|
|
|
|
* @param templ Template of the string to generate
|
|
|
|
* @return Copy of template with "\0" - "\9" replaced with submatches
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String replaceMatches(const String& templ) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the total number of submatches from the last match, 0 if no match
|
|
|
|
* @return Number of matching subexpressions
|
|
|
|
*/
|
|
|
|
int matchCount() const;
|
|
|
|
|
2004-11-29 21:01:04 +00:00
|
|
|
/**
|
|
|
|
* Splits the string at a delimiter character
|
|
|
|
* @param separator Character where to split the string
|
|
|
|
* @param emptyOK True if empty strings should be inserted in list
|
|
|
|
* @return A newly allocated list of strings, must be deleted after use
|
|
|
|
*/
|
|
|
|
ObjList* split(char separator, bool emptyOK = true) const;
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Create an escaped string suitable for use in messages
|
|
|
|
* @param str String to convert to escaped format
|
|
|
|
* @param extraEsc Character to escape other than the default ones
|
|
|
|
* @return The string with special characters escaped
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static String msgEscape(const char* str, char extraEsc = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Create an escaped string suitable for use in messages
|
|
|
|
* @param extraEsc Character to escape other than the default ones
|
|
|
|
* @return The string with special characters escaped
|
|
|
|
*/
|
|
|
|
inline String msgEscape(char extraEsc = 0) const
|
|
|
|
{ return msgEscape(c_str(),extraEsc); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Decode an escaped string back to its raw form
|
|
|
|
* @param str String to convert to unescaped format
|
|
|
|
* @param errptr Pointer to an integer to receive the place of 1st error
|
|
|
|
* @param extraEsc Character to unescape other than the default ones
|
|
|
|
* @return The string with special characters unescaped
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static String msgUnescape(const char* str, int* errptr = 0, char extraEsc = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Decode an escaped string back to its raw form
|
|
|
|
* @param errptr Pointer to an integer to receive the place of 1st error
|
|
|
|
* @param extraEsc Character to unescape other than the default ones
|
|
|
|
* @return The string with special characters unescaped
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline String msgUnescape(int* errptr = 0, char extraEsc = 0) const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return msgUnescape(c_str(),errptr,extraEsc); }
|
|
|
|
|
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Called whenever the value changed (except in constructors).
|
|
|
|
*/
|
|
|
|
virtual void changed();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void clearMatches();
|
2005-03-20 03:11:53 +00:00
|
|
|
char* m_string;
|
2004-05-22 00:05:20 +00:00
|
|
|
unsigned int m_length;
|
2005-03-20 03:11:53 +00:00
|
|
|
// I hope every C++ compiler now knows about mutable...
|
2004-05-22 00:05:20 +00:00
|
|
|
mutable unsigned int m_hash;
|
2005-03-20 03:11:53 +00:00
|
|
|
StringMatchPrivate* m_matches;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Utility function to replace NULL string pointers with an empty string
|
|
|
|
* @param str Pointer to a C string that may be NULL
|
|
|
|
* @return Original pointer or pointer to an empty string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline const char *c_safe(const char* str)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return str ? str : ""; }
|
|
|
|
|
2005-03-28 22:27:26 +00:00
|
|
|
/**
|
|
|
|
* Utility function to check if a C string is null or empty
|
|
|
|
* @param str Pointer to a C string
|
|
|
|
* @return True if str is NULL or starts with a NUL character
|
|
|
|
*/
|
|
|
|
inline bool null(const char* str)
|
|
|
|
{ return !(str && *str); }
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Concatenation operator for strings.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API String operator+(const String& s1, const String& s2);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Concatenation operator for strings.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API String operator+(const String& s1, const char* s2);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Concatenation operator for strings.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API String operator+(const char* s1, const String& s2);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Prevent careless programmers from overwriting the string
|
|
|
|
* @see TelEngine::String::operator=
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline const char *strcpy(String& dest, const char* src)
|
|
|
|
{ dest = src; return dest.c_str(); }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Prevent careless programmers from overwriting the string
|
|
|
|
* @see TelEngine::String::operator+=
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline const char *strcat(String& dest, const char* src)
|
|
|
|
{ dest += src; return dest.c_str(); }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Utility function to look up a string in a token table,
|
|
|
|
* interpret as number if it fails
|
|
|
|
* @param str String to look up
|
|
|
|
* @param tokens Pointer to the token table
|
|
|
|
* @param defvalue Value to return if lookup and conversion fail
|
|
|
|
* @param base Default base to use to convert to number
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API int lookup(const char* str, const TokenDict* tokens, int defvalue = 0, int base = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Utility function to look up a number in a token table
|
|
|
|
* @param value Value to search for
|
|
|
|
* @param tokens Pointer to the token table
|
|
|
|
* @param defvalue Value to return if lookup fails
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
YATE_API const char* lookup(int value, const TokenDict* tokens, const char* defvalue = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A regular expression matching class.
|
|
|
|
* @short A regexp matching class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Regexp : public String
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
friend class String;
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new, empty regexp.
|
|
|
|
*/
|
|
|
|
Regexp();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new initialized regexp.
|
|
|
|
* @param value Initial value of the regexp.
|
2005-02-06 21:06:32 +00:00
|
|
|
* @param extended True to use POSIX Extended Regular Expression syntax
|
|
|
|
* @param insensitive True to not differentiate case
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Regexp(const char* value, bool extended = false, bool insensitive = false);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy constructor.
|
|
|
|
* @param value Initial value of the regexp.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Regexp(const Regexp& value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroys the regexp, disposes the memory.
|
|
|
|
*/
|
|
|
|
virtual ~Regexp();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment from char* operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline Regexp& operator=(const char* value)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ String::operator=(value); return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes sure the regular expression is compiled
|
|
|
|
* @return True if successfully compiled, false on error
|
|
|
|
*/
|
|
|
|
bool compile();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the pattern matches a given value
|
|
|
|
* @param value String to check for match
|
|
|
|
* @return True if matches, false otherwise
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool matches(const char* value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Checks if the pattern matches a string
|
|
|
|
* @param value String to check for match
|
|
|
|
* @return True if matches, false otherwise
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
virtual bool matches(const String& value) const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return matches(value.safe()); }
|
|
|
|
|
2005-02-06 21:06:32 +00:00
|
|
|
/**
|
|
|
|
* Change the expression matching flags
|
|
|
|
* @param extended True to use POSIX Extended Regular Expression syntax
|
|
|
|
* @param insensitive True to not differentiate case
|
|
|
|
*/
|
|
|
|
void setFlags(bool extended, bool insensitive);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the POSIX Extended syntax flag
|
|
|
|
* @return True if using POSIX Extended Regular Expression syntax
|
|
|
|
*/
|
|
|
|
bool isExtended() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return the Case Insensitive flag
|
|
|
|
* @return True if not differentiating case
|
|
|
|
*/
|
|
|
|
bool isCaseInsensitive() const;
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Called whenever the value changed (except in constructors) to recompile.
|
|
|
|
*/
|
|
|
|
virtual void changed();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void cleanup();
|
|
|
|
bool matches(const char *value, StringMatchPrivate *matches);
|
2005-03-20 03:11:53 +00:00
|
|
|
void* m_regexp;
|
2005-02-06 21:06:32 +00:00
|
|
|
int m_flags;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A string class with a hashed string name
|
|
|
|
* @short A named string class.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API NamedString : public String
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new named string.
|
|
|
|
* @param name Name of this string
|
|
|
|
* @param value Initial value of the string.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedString(const char* name, const char* value = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the name of this string.
|
|
|
|
* @return A hashed string with the name of the string
|
|
|
|
*/
|
|
|
|
inline const String& name() const
|
|
|
|
{ return m_name; }
|
|
|
|
|
2004-08-20 00:46:33 +00:00
|
|
|
/**
|
2004-12-04 15:44:54 +00:00
|
|
|
* Get a string representation of this object
|
|
|
|
* @return A reference to the name of this object
|
|
|
|
*/
|
|
|
|
virtual const String& toString() const;
|
|
|
|
|
|
|
|
/**
|
2004-08-20 00:46:33 +00:00
|
|
|
* Value assignment operator
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline NamedString& operator=(const char* value)
|
2004-08-20 00:46:33 +00:00
|
|
|
{ String::operator=(value); return *this; }
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
private:
|
|
|
|
NamedString(); // no default constructor please
|
|
|
|
String m_name;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The Time class holds a time moment with microsecond accuracy
|
|
|
|
* @short A time holding class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Time
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Constructs a Time object from the current time
|
|
|
|
*/
|
2004-12-08 00:04:26 +00:00
|
|
|
inline Time()
|
|
|
|
: m_time(now())
|
|
|
|
{ }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Constructs a Time object from a given time
|
|
|
|
* @param usec Time in microseconds
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline Time(u_int64_t usec)
|
2004-12-08 00:04:26 +00:00
|
|
|
: m_time(usec)
|
|
|
|
{ }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Constructs a Time object from a timeval structure
|
|
|
|
* @param tv Pointer to the timeval structure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline Time(struct timeval* tv)
|
2004-12-08 00:04:26 +00:00
|
|
|
: m_time(fromTimeval(tv))
|
|
|
|
{ }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Do-nothing destructor that keeps the compiler from complaining
|
|
|
|
* about inlining derivates or members of Time type
|
|
|
|
*/
|
|
|
|
inline ~Time()
|
|
|
|
{ }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get time in seconds
|
|
|
|
* @return Time in seconds since the Epoch
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline u_int32_t sec() const
|
|
|
|
{ return (u_int32_t)((m_time+500000) / 1000000); }
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get time in milliseconds
|
|
|
|
* @return Time in milliseconds since the Epoch
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline u_int64_t msec() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return (m_time+500) / 1000; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get time in microseconds
|
|
|
|
* @return Time in microseconds since the Epoch
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline u_int64_t usec() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_time; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Conversion to microseconds operator
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline operator u_int64_t() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_time; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline Time& operator=(u_int64_t usec)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ m_time = usec; return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Offsetting operator.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline Time& operator+=(int64_t delta)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ m_time += delta; return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Offsetting operator.
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline Time& operator-=(int64_t delta)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ m_time -= delta; return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fill in a timeval struct from a value in microseconds
|
|
|
|
* @param tv Pointer to the timeval structure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline void toTimeval(struct timeval* tv) const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ toTimeval(tv, m_time); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fill in a timeval struct from a value in microseconds
|
|
|
|
* @param tv Pointer to the timeval structure
|
|
|
|
* @param usec Time to convert to timeval
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
static void toTimeval(struct timeval* tv, u_int64_t usec);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convert time in a timeval struct to microseconds
|
|
|
|
* @param tv Pointer to the timeval structure
|
|
|
|
* @return Corresponding time in microseconds or zero if tv is NULL
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
static u_int64_t fromTimeval(struct timeval* tv);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the current system time in microseconds
|
|
|
|
* @return Time in microseconds since the Epoch
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
static u_int64_t now();
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
private:
|
2005-04-02 00:49:38 +00:00
|
|
|
u_int64_t m_time;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
2005-02-28 14:09:40 +00:00
|
|
|
/**
|
|
|
|
* A class to compute and check MD5 digests
|
|
|
|
* @short A standard MD5 digest calculator
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API MD5
|
2005-02-28 14:09:40 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Construct a fresh initialized instance
|
|
|
|
*/
|
|
|
|
MD5();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Copy constructor
|
|
|
|
* @param original MD5 instance to copy
|
|
|
|
*/
|
|
|
|
MD5(const MD5& original);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct a digest from a buffer of data
|
|
|
|
* @param buf Pointer to the data to be included in digest
|
|
|
|
* @param len Length of data in the buffer
|
|
|
|
*/
|
|
|
|
MD5(const void* buf, unsigned int len);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Construct a digest from a String
|
|
|
|
* @param str String to be included in digest
|
|
|
|
*/
|
|
|
|
MD5(const String& str);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroy the instance, free allocated memory
|
|
|
|
*/
|
|
|
|
~MD5();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
MD5& operator=(const MD5& original);
|
2005-02-28 14:09:40 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear the digest and prepare for reuse
|
|
|
|
*/
|
|
|
|
void clear();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Finalize the digest computation, make result ready.
|
|
|
|
* Subsequent calls to @ref update() will fail
|
|
|
|
*/
|
|
|
|
void finalize();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Update the digest from a buffer of data
|
|
|
|
* @param buf Pointer to the data to be included in digest
|
|
|
|
* @param len Length of data in the buffer
|
|
|
|
* @return True if success, false if @ref finalize() was already called
|
|
|
|
*/
|
|
|
|
bool update(const void* buf, unsigned int len);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Update the digest from the content of a String
|
|
|
|
* @param str String to be included in digest
|
|
|
|
* @return True if success, false if @ref finalize() was already called
|
|
|
|
*/
|
|
|
|
inline bool update(const String& str)
|
|
|
|
{ return update(str.c_str(), str.length()); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns a pointer to the raw 16-byte binary value of the message digest.
|
|
|
|
* The digest is finalized if if wasn't already
|
|
|
|
* @return Pointer to the raw digest data or NULL if some error occured
|
|
|
|
*/
|
|
|
|
const unsigned char* rawDigest();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the standard hexadecimal representation of the message digest.
|
|
|
|
* The digest is finalized if if wasn't already
|
|
|
|
* @return A String which holds the hex digest or a null one if some error occured
|
|
|
|
*/
|
|
|
|
const String& hexDigest();
|
|
|
|
|
|
|
|
private:
|
|
|
|
void init();
|
|
|
|
void* m_private;
|
|
|
|
String m_hex;
|
|
|
|
unsigned char m_bin[16];
|
|
|
|
};
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* This class holds a named list of named strings
|
|
|
|
* @short A named string container class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API NamedList : public String
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new named list.
|
|
|
|
* @param name Name of the list - must not be NULL or empty
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList(const char* name);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of parameters
|
|
|
|
* @return Count of named strings
|
|
|
|
*/
|
|
|
|
inline unsigned int length() const
|
|
|
|
{ return m_params.length(); }
|
|
|
|
|
2004-12-21 04:16:09 +00:00
|
|
|
/**
|
|
|
|
* Get the number of non-null parameters
|
|
|
|
* @return Count of existing named strings
|
|
|
|
*/
|
|
|
|
inline unsigned int count() const
|
|
|
|
{ return m_params.count(); }
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Add a named string to the parameter list.
|
|
|
|
* @param param Parameter to add
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList& addParam(NamedString* param);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a named string to the parameter list.
|
|
|
|
* @param name Name of the new string
|
|
|
|
* @param value Value of the new string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList& addParam(const char* name, const char* value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a named string in the parameter list.
|
|
|
|
* @param param Parameter to set or add
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList& setParam(NamedString* param);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set a named string in the parameter list.
|
|
|
|
* @param name Name of the string
|
|
|
|
* @param value Value of the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList& setParam(const char* name, const char* value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Clars all instances of a named string in the parameter list.
|
|
|
|
* @param name Name of the string to remove
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList& clearParam(const String& name);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Locate a named string in the parameter list.
|
|
|
|
* @param name Name of parameter to locate
|
|
|
|
* @return A pointer to the named string or NULL.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedString* getParam(const String& name) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Locate a named string in the parameter list.
|
|
|
|
* @param index Index of the parameter to locate
|
|
|
|
* @return A pointer to the named string or NULL.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedString* getParam(unsigned int index) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the value of a named parameter.
|
|
|
|
* @param name Name of parameter to locate
|
|
|
|
* @param defvalue Default value to return if not found
|
|
|
|
* @return The string contained in the named parameter or the default
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
const char* getValue(const String& name, const char* defvalue = 0) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
NamedList(); // no default constructor please
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList(const NamedList& value); // no copy constructor
|
|
|
|
NamedList& operator=(const NamedList& value); // no assignment please
|
2004-05-22 00:05:20 +00:00
|
|
|
ObjList m_params;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A class for parsing and quickly accessing INI style configuration files
|
|
|
|
* @short Configuration file handling
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Configuration : public String
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Create an empty configuration
|
|
|
|
*/
|
|
|
|
Configuration();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Create a configuration from a file
|
|
|
|
* @param filename Name of file to initialize from
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Configuration(const char* filename);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment from string operator
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline Configuration& operator=(const String& value)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ String::operator=(value); return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of sections
|
|
|
|
* @return Count of sections
|
|
|
|
*/
|
|
|
|
inline unsigned int sections() const
|
|
|
|
{ return m_sections.length(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive an entire section
|
|
|
|
* @param index Index of the section
|
|
|
|
* @return The section's content or NULL if no such section
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList* getSection(unsigned int index) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive an entire section
|
|
|
|
* @param sect Name of the section
|
|
|
|
* @return The section's content or NULL if no such section
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedList* getSection(const String& sect) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Locate a key/value pair in the section.
|
|
|
|
* @param sect Name of the section
|
|
|
|
* @param key Name of the key in section
|
|
|
|
* @return A pointer to the key/value pair or NULL.
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
NamedString* getKey(const String& sect, const String& key) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the value of a key in a section.
|
|
|
|
* @param sect Name of the section
|
|
|
|
* @param key Name of the key in section
|
|
|
|
* @param defvalue Default value to return if not found
|
|
|
|
* @return The string contained in the key or the default
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
const char* getValue(const String& sect, const String& key, const char* defvalue = 0) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the numeric value of a key in a section.
|
|
|
|
* @param sect Name of the section
|
|
|
|
* @param key Name of the key in section
|
|
|
|
* @param defvalue Default value to return if not found
|
|
|
|
* @return The number contained in the key or the default
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
int getIntValue(const String& sect, const String& key, int defvalue = 0) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the numeric value of a key in a section trying first a table lookup.
|
|
|
|
* @param sect Name of the section
|
|
|
|
* @param key Name of the key in section
|
|
|
|
* @param tokens A pointer to an array of tokens to try to lookup
|
|
|
|
* @param defvalue Default value to return if not found
|
|
|
|
* @return The number contained in the key or the default
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
int getIntValue(const String& sect, const String& key, const TokenDict* tokens, int defvalue = 0) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive the boolean value of a key in a section.
|
|
|
|
* @param sect Name of the section
|
|
|
|
* @param key Name of the key in section
|
|
|
|
* @param defvalue Default value to return if not found
|
|
|
|
* @return The boolean value contained in the key or the default
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool getBoolValue(const String& sect, const String& key, bool defvalue = false) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Deletes an entire section
|
|
|
|
* @param sect Name of section to delete, NULL to delete all
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
void clearSection(const char* sect = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Deletes a key/value pair
|
|
|
|
* @param sect Name of section
|
|
|
|
* @param key Name of the key to delete
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
void clearKey(const String& sect, const String& key);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2004-12-01 00:54:04 +00:00
|
|
|
/**
|
|
|
|
* Add the value of a key in a section.
|
|
|
|
* @param sect Name of the section, will be created if missing
|
|
|
|
* @param key Name of the key to add in the section
|
|
|
|
* @param value Value to set in the key
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
void addValue(const String& sect, const char* key, const char* value = 0);
|
2004-12-01 00:54:04 +00:00
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Set the value of a key in a section.
|
|
|
|
* @param sect Name of the section, will be created if missing
|
|
|
|
* @param key Name of the key in section, will be created if missing
|
|
|
|
* @param value Value to set in the key
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
void setValue(const String& sect, const char* key, const char* value = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the numeric value of a key in a section.
|
|
|
|
* @param sect Name of the section, will be created if missing
|
|
|
|
* @param key Name of the key in section, will be created if missing
|
|
|
|
* @param value Value to set in the key
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
void setValue(const String& sect, const char* key, int value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the boolean value of a key in a section.
|
|
|
|
* @param sect Name of the section, will be created if missing
|
|
|
|
* @param key Name of the key in section, will be created if missing
|
|
|
|
* @param value Value to set in the key
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
void setValue(const String& sect, const char* key, bool value);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Load the configuration from file
|
|
|
|
* @return True if successfull, false for failure
|
|
|
|
*/
|
|
|
|
bool load();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Save the configuration to file
|
|
|
|
* @return True if successfull, false for failure
|
|
|
|
*/
|
|
|
|
bool save() const;
|
|
|
|
|
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
Configuration(const Configuration& value); // no copy constructor
|
|
|
|
Configuration& operator=(const Configuration& value); // no assignment please
|
|
|
|
ObjList *getSectHolder(const String& sect) const;
|
|
|
|
ObjList *makeSectHolder(const String& sect);
|
2004-05-22 00:05:20 +00:00
|
|
|
ObjList m_sections;
|
|
|
|
};
|
|
|
|
|
|
|
|
class MessageDispatcher;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This class holds the messages that are moved around in the engine.
|
|
|
|
* @short A message container class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Message : public NamedList
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
friend class MessageDispatcher;
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new message.
|
|
|
|
*
|
|
|
|
* @param name Name of the message - must not be NULL or empty
|
|
|
|
* @param retval Default return value
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Message(const char* name, const char* retval = 0);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2005-03-28 22:27:26 +00:00
|
|
|
/**
|
|
|
|
* Destruct the message and dereferences any user data
|
|
|
|
*/
|
|
|
|
~Message();
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Retrive a reference to the value returned by the message.
|
|
|
|
* @return A reference to the value the message will return
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline String& retValue()
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_return; }
|
|
|
|
|
|
|
|
/**
|
2005-03-28 22:27:26 +00:00
|
|
|
* Retrive the object associated with the message
|
|
|
|
* @return Pointer to arbitrary user RefObject
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-03-28 22:27:26 +00:00
|
|
|
inline RefObject* userData() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_data; }
|
|
|
|
|
|
|
|
/**
|
2005-03-28 22:27:26 +00:00
|
|
|
* Set obscure data associated with the message.
|
|
|
|
* The user data is reference counted to avoid stray pointers.
|
|
|
|
* @param data Pointer to arbitrary user data
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-03-28 22:27:26 +00:00
|
|
|
void userData(RefObject* data);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Retrive a reference to the creation time of the message.
|
|
|
|
* @return A reference to the Time when the message was created
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline Time& msgTime()
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_time; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Name assignment operator
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline Message& operator=(const char* value)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ String::operator=(value); return *this; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Encode the message into a string adequate for sending for processing
|
|
|
|
* to an external communication interface
|
|
|
|
* @param id Unique identifier to add to the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String encode(const char* id) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Encode the message into a string adequate for sending as answer
|
|
|
|
* to an external communication interface
|
|
|
|
* @param received True if message was processed locally
|
|
|
|
* @param id Unique identifier to add to the string
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
String encode(bool received, const char* id) const;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Decode a string from an external communication interface for processing
|
|
|
|
* in the engine. The message is modified accordingly.
|
|
|
|
* @param str String to decode
|
|
|
|
* @param id A String object in which the identifier is stored
|
|
|
|
* @return -2 for success, -1 if the string was not a text form of a
|
|
|
|
* message, index of first erroneous character if failed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
int decode(const char* str, String& id);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Decode a string from an external communication interface that is an
|
|
|
|
* answer to a specific external processing request.
|
|
|
|
* @param str String to decode
|
|
|
|
* @param received Pointer to variable to store the dispatch return value
|
|
|
|
* @param id The identifier expected
|
|
|
|
* @return -2 for success, -1 if the string was not the expected answer,
|
|
|
|
* index of first erroneous character if failed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
int decode(const char* str, bool& received, const char* id);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Notify the message it has been dispatched
|
|
|
|
*/
|
|
|
|
virtual void dispatched(bool accepted)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
private:
|
|
|
|
Message(); // no default constructor please
|
2005-03-20 03:11:53 +00:00
|
|
|
Message(const Message& value); // no copy constructor
|
|
|
|
Message& operator=(const Message& value); // no assignment please
|
2004-05-22 00:05:20 +00:00
|
|
|
String m_return;
|
|
|
|
Time m_time;
|
2005-03-28 22:27:26 +00:00
|
|
|
RefObject* m_data;
|
2005-03-20 03:11:53 +00:00
|
|
|
void commonEncode(String& str) const;
|
|
|
|
int commonDecode(const char* str, int offs);
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2004-12-08 00:04:26 +00:00
|
|
|
* The purpose of this class is to hold a message received method that is
|
|
|
|
* called for matching messages. It holds as well the matching criteria
|
|
|
|
* and priority among other handlers.
|
|
|
|
* @short A message handler
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API MessageHandler : public String
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
friend class MessageDispatcher;
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new message handler.
|
|
|
|
* @param name Name of the handled message - may be NULL
|
|
|
|
* @param priority Priority of the handler, 0 = top
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
MessageHandler(const char* name, unsigned priority = 100);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Handler destructor.
|
|
|
|
*/
|
|
|
|
virtual ~MessageHandler();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This method is called whenever the registered name matches the message.
|
|
|
|
* @param msg The received message
|
|
|
|
* @return True to stop processing, false to try other handlers
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
virtual bool received(Message& msg) = 0;
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Find out the priority of the handler
|
|
|
|
* @return Stored priority of the handler, 0 = top
|
|
|
|
*/
|
|
|
|
inline unsigned priority() const
|
|
|
|
{ return m_priority; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
unsigned m_priority;
|
2005-03-20 03:11:53 +00:00
|
|
|
MessageDispatcher* m_dispatcher;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2004-12-08 00:04:26 +00:00
|
|
|
* A multiple message receiver to be invoked by a message relay
|
|
|
|
* @short A multiple message receiver
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API MessageReceiver : public GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* This method is called from the message relay.
|
|
|
|
* @param msg The received message
|
|
|
|
* @param id The identifier with which the relay was created
|
|
|
|
* @return True to stop processing, false to try other handlers
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
virtual bool received(Message& msg, int id) = 0;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A message handler that allows to relay several messages to a single receiver
|
2004-12-08 00:04:26 +00:00
|
|
|
* @short A message handler relay
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API MessageRelay : public MessageHandler
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new message relay.
|
|
|
|
* @param name Name of the handled message - may be NULL
|
|
|
|
* @param receiver Receiver of th relayed messages
|
|
|
|
* @param id Numeric identifier to pass to receiver
|
|
|
|
* @param priority Priority of the handler, 0 = top
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
MessageRelay(const char* name, MessageReceiver* receiver, int id, int priority = 100)
|
2004-05-22 00:05:20 +00:00
|
|
|
: MessageHandler(name,priority), m_receiver(receiver), m_id(id) { }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This method is called whenever the registered name matches the message.
|
|
|
|
* @param msg The received message
|
|
|
|
* @return True to stop processing, false to try other handlers
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
virtual bool received(Message& msg)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_receiver ? m_receiver->received(msg,m_id) : false; }
|
|
|
|
|
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
MessageReceiver* m_receiver;
|
2004-05-22 00:05:20 +00:00
|
|
|
int m_id;
|
|
|
|
};
|
|
|
|
|
|
|
|
class MutexPrivate;
|
|
|
|
class ThreadPrivate;
|
|
|
|
|
|
|
|
/**
|
2004-12-08 00:04:26 +00:00
|
|
|
* A simple mutual exclusion for locking access between threads
|
|
|
|
* @short Mutex support
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Mutex
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
friend class MutexPrivate;
|
|
|
|
public:
|
|
|
|
/**
|
2005-01-17 16:05:14 +00:00
|
|
|
* Construct a new unlocked fast mutex
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
|
|
|
Mutex();
|
|
|
|
|
2005-01-17 16:05:14 +00:00
|
|
|
/**
|
|
|
|
* Construct a new unlocked mutex
|
|
|
|
* @param recursive True if the mutex has to be recursive (reentrant),
|
|
|
|
* false for a normal fast mutex
|
|
|
|
*/
|
|
|
|
Mutex(bool recursive);
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
2005-03-20 03:11:53 +00:00
|
|
|
* Copy constructor creates a shared mutex
|
2004-05-22 00:05:20 +00:00
|
|
|
* @param original Reference of the mutex to share
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Mutex(const Mutex& orginal);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroy the mutex
|
|
|
|
*/
|
|
|
|
~Mutex();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Assignment operator makes the mutex shared with the original
|
|
|
|
* @param original Reference of the mutex to share
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Mutex& operator=(const Mutex& original);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Attempt to lock the mutex and eventually wait for it
|
|
|
|
* @param maxait Time in microseconds to wait for the mutex, -1 wait forever
|
|
|
|
* @return True if successfully locked, false on failure
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
bool lock(int64_t maxwait = -1);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Unlock the mutex, does never wait
|
|
|
|
*/
|
|
|
|
void unlock();
|
|
|
|
|
2005-02-28 08:25:41 +00:00
|
|
|
/**
|
|
|
|
* Check if the mutex is currently locked - as it's asynchronous it
|
|
|
|
* guarantees nothing if other thread changes the mutex's status
|
|
|
|
* @return True if the mutex was locked when the function was called
|
|
|
|
*/
|
|
|
|
bool locked() const;
|
|
|
|
|
2004-10-24 21:35:54 +00:00
|
|
|
/**
|
|
|
|
* Check if the mutex is unlocked (try to lock and unlock the mutex)
|
|
|
|
* @param maxait Time in microseconds to wait for the mutex, -1 wait forever
|
|
|
|
* @return True if successfully locked and unlocked, false on failure
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
bool check(int64_t maxwait = -1);
|
2004-10-24 21:35:54 +00:00
|
|
|
|
2005-01-17 16:05:14 +00:00
|
|
|
/**
|
|
|
|
* Check if this mutex is recursive or not
|
2005-03-20 03:11:53 +00:00
|
|
|
* @return True if this is a recursive mutex, false for a fast mutex
|
2005-01-17 16:05:14 +00:00
|
|
|
*/
|
|
|
|
bool recursive() const;
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Get the number of mutexes counting the shared ones only once
|
|
|
|
* @return Count of individual mutexes
|
|
|
|
*/
|
|
|
|
static int count();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of currently locked mutexes
|
|
|
|
* @return Count of locked mutexes, should be zero at program exit
|
|
|
|
*/
|
|
|
|
static int locks();
|
|
|
|
|
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
MutexPrivate* privDataCopy() const;
|
|
|
|
MutexPrivate* m_private;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* A lock is a stack allocated (automatic) object that locks a mutex on
|
2004-12-08 00:04:26 +00:00
|
|
|
* creation and unlocks it on destruction - typically when exiting a block
|
|
|
|
* @short Ephemeral mutex locking object
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Lock
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Create the lock, try to lock the mutex
|
|
|
|
* @param mutex Reference to the mutex to lock
|
|
|
|
* @param maxait Time in microseconds to wait for the mutex, -1 wait forever
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline Lock(Mutex& mutex, int64_t maxwait = -1)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ m_mutex = mutex.lock(maxwait) ? &mutex : 0; }
|
|
|
|
|
2004-12-08 00:04:26 +00:00
|
|
|
/**
|
|
|
|
* Create the lock, try to lock the mutex
|
|
|
|
* @param mutex Pointer to the mutex to lock
|
|
|
|
* @param maxait Time in microseconds to wait for the mutex, -1 wait forever
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
inline Lock(Mutex* mutex, int64_t maxwait = -1)
|
2004-12-08 00:04:26 +00:00
|
|
|
{ m_mutex = (mutex && mutex->lock(maxwait)) ? mutex : 0; }
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Destroy the lock, unlock the mutex if it was locked
|
|
|
|
*/
|
|
|
|
inline ~Lock()
|
|
|
|
{ if (m_mutex) m_mutex->unlock(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Return a pointer to the mutex this lock holds
|
|
|
|
* @return A mutex pointer or NULL if locking failed
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline Mutex* mutex() const
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return m_mutex; }
|
|
|
|
|
2004-10-24 21:35:54 +00:00
|
|
|
/**
|
|
|
|
* Unlock the mutex if it was locked and drop the reference to it
|
|
|
|
*/
|
|
|
|
inline void drop()
|
|
|
|
{ if (m_mutex) m_mutex->unlock(); m_mutex = 0; }
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
Mutex* m_mutex;
|
2004-12-08 00:04:26 +00:00
|
|
|
|
|
|
|
/** Make sure no Lock is ever created on heap */
|
|
|
|
inline void* operator new(size_t);
|
|
|
|
|
|
|
|
/** Never allocate an array of this class */
|
|
|
|
inline void* operator new[](size_t);
|
|
|
|
|
|
|
|
/** No copy constructor */
|
|
|
|
inline Lock(const Lock&);
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2004-12-08 00:04:26 +00:00
|
|
|
* This class holds the action to execute a certain task, usually in a
|
|
|
|
* different execution thread.
|
|
|
|
* @short Encapsulates a runnable task
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Runnable
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
2004-12-08 00:04:26 +00:00
|
|
|
* This method is called in another thread to do the actual job.
|
|
|
|
* When it returns the job or thread terminates.
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
|
|
|
virtual void run() = 0;
|
2004-12-08 00:04:26 +00:00
|
|
|
};
|
2004-05-22 00:05:20 +00:00
|
|
|
|
2004-12-08 00:04:26 +00:00
|
|
|
/**
|
|
|
|
* A thread is a separate execution context that exists in the same address
|
|
|
|
* space. Threads make better use of multiple processor machines and allow
|
|
|
|
* blocking one execution thread while allowing other to run.
|
|
|
|
* @short Thread support class
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Thread : public Runnable
|
2004-12-08 00:04:26 +00:00
|
|
|
{
|
|
|
|
friend class ThreadPrivate;
|
|
|
|
public:
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* This method is called when the current thread terminates.
|
|
|
|
*/
|
|
|
|
virtual void cleanup();
|
|
|
|
|
2004-11-01 00:07:00 +00:00
|
|
|
/**
|
|
|
|
* Actually starts running the new thread which lingers after creation
|
|
|
|
* @return True if an error occured, false if started ok
|
|
|
|
*/
|
|
|
|
bool startup();
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Check if the thread creation failed
|
|
|
|
* @return True if an error occured, false if created ok
|
|
|
|
*/
|
|
|
|
bool error() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the thread is running or not
|
2004-11-01 00:07:00 +00:00
|
|
|
* @return True if running, false if it has terminated or no startup called
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
|
|
|
bool running() const;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Give up the currently running timeslice
|
|
|
|
*/
|
|
|
|
static void yield();
|
|
|
|
|
2005-04-02 00:49:38 +00:00
|
|
|
/**
|
|
|
|
* Sleep for a number of seconds
|
|
|
|
* @param sec Number of seconds to sleep
|
|
|
|
*/
|
|
|
|
static void sleep(unsigned int sec);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sleep for a number of milliseconds
|
|
|
|
* @param sec Number of milliseconds to sleep
|
|
|
|
*/
|
|
|
|
static void msleep(unsigned long msec);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sleep for a number of microseconds
|
|
|
|
* @param sec Number of microseconds to sleep
|
|
|
|
*/
|
|
|
|
static void usleep(unsigned long usec);
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
/**
|
|
|
|
* Get a pointer to the currently running thread
|
|
|
|
* @return A pointer to the current thread or NULL for main thread
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static Thread* current();
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of threads
|
|
|
|
* @return Count of threads except the main one
|
|
|
|
*/
|
|
|
|
static int count();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Terminates the current thread.
|
|
|
|
*/
|
|
|
|
static void exit();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Terminates the specified thread.
|
|
|
|
*/
|
|
|
|
void cancel();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Kills all other running threads. Ouch!
|
|
|
|
* Must be called from the main thread or it does nothing.
|
|
|
|
*/
|
|
|
|
static void killall();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* On some platforms this method kills all other running threads.
|
2004-08-19 22:53:55 +00:00
|
|
|
* Must be called after fork() but before any exec*() call.
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
|
|
|
static void preExec();
|
|
|
|
|
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Creates and starts a new thread
|
|
|
|
* @param name Static name of the thread (for debugging purpose only)
|
|
|
|
*/
|
|
|
|
Thread(const char *name = 0);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The destructor is called when the thread terminates
|
|
|
|
*/
|
|
|
|
virtual ~Thread();
|
|
|
|
|
|
|
|
private:
|
2005-03-20 03:11:53 +00:00
|
|
|
ThreadPrivate* m_private;
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2004-12-08 00:04:26 +00:00
|
|
|
* The dispatcher class is a hub that holds a list of handlers to be called
|
|
|
|
* for the messages that pass trough the hub. It can also handle a queue of
|
|
|
|
* messages that are typically dispatched by a separate thread.
|
|
|
|
* @short A message dispatching hub
|
2004-05-22 00:05:20 +00:00
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API MessageDispatcher : public GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new message dispatcher.
|
|
|
|
*/
|
|
|
|
MessageDispatcher();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroys the dispatcher and the installed handlers.
|
|
|
|
*/
|
|
|
|
~MessageDispatcher();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Installs a handler in the dispatcher.
|
|
|
|
* @param handler A pointer to the handler to install
|
|
|
|
* @return True on success, false on failure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool install(MessageHandler* handler);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Uninstalls a handler from the dispatcher.
|
|
|
|
* @param handler A pointer to the handler to uninstall
|
|
|
|
* @return True on success, false on failure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool uninstall(MessageHandler* handler);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Dispatch a message to the installed handlers
|
|
|
|
* @param msg The message to dispatch
|
|
|
|
* @return True if one handler accepted it, false if all ignored
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool dispatch(Message& msg);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the number of messages waiting in the queue
|
|
|
|
* @return Count of messages in the queue
|
|
|
|
*/
|
|
|
|
inline unsigned int queueLength() const
|
|
|
|
{ return m_messages.count(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Put a message in the waiting queue
|
|
|
|
* @param msg The message to enqueue, will be destroyed after dispatching
|
|
|
|
* @return True if successfully queued, false otherwise
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool enqueue(Message* msg);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Dispatch all messages from the waiting queue
|
|
|
|
*/
|
|
|
|
void dequeue();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Dispatch one message from the waiting queue
|
|
|
|
* @return True if success, false if the queue is empty
|
|
|
|
*/
|
|
|
|
bool dequeueOne();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear all the message handlers
|
|
|
|
*/
|
|
|
|
inline void clear()
|
|
|
|
{ m_handlers.clear(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Install or remove a hook to catch messages after being dispatched
|
|
|
|
* @param hookFunc Pointer to a callback function
|
|
|
|
*/
|
|
|
|
inline void setHook(void (*hookFunc)(Message &, bool) = 0)
|
|
|
|
{ m_hook = hookFunc; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
ObjList m_handlers;
|
|
|
|
ObjList m_messages;
|
|
|
|
Mutex m_mutex;
|
|
|
|
void (*m_hook)(Message &, bool);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialization and information about plugins.
|
|
|
|
* Plugins are located in @em shared libraries that are loaded at runtime.
|
|
|
|
*
|
|
|
|
*<pre>
|
|
|
|
* // Create static Plugin object by using the provided macro
|
|
|
|
* INIT_PLUGIN(Plugin);
|
|
|
|
*</pre>
|
|
|
|
* @short Plugin support
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Plugin : public GenObject
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Creates a new Plugin container.
|
|
|
|
* @param name the undecorated name of the library that contains the plugin
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
Plugin(const char* name);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Creates a new Plugin container.
|
|
|
|
* Alternate constructor which is also the default.
|
|
|
|
*/
|
|
|
|
Plugin();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Destroys the plugin.
|
|
|
|
* The destructor must never be called directly - the Loader will do it when @ref refCount() reaches zero.
|
|
|
|
*/
|
|
|
|
virtual ~Plugin();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize the plugin after it was loaded and registered.
|
|
|
|
*/
|
|
|
|
virtual void initialize() = 0;
|
2004-11-01 00:07:00 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the module is actively used.
|
|
|
|
* @return True if the plugin is in use, false if should be ok to restart
|
|
|
|
*/
|
|
|
|
virtual bool isBusy() const
|
|
|
|
{ return false; }
|
2004-05-22 00:05:20 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Macro to create static instance of the plugin
|
|
|
|
* @param pclass Class of the plugin to create
|
|
|
|
*/
|
|
|
|
#define INIT_PLUGIN(pclass) static pclass __plugin
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This class holds global information about the engine.
|
|
|
|
* Note: this is a singleton class.
|
|
|
|
*
|
|
|
|
* @short Engine globals
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
class YATE_API Engine
|
2004-05-22 00:05:20 +00:00
|
|
|
{
|
|
|
|
friend class EnginePrivate;
|
|
|
|
public:
|
|
|
|
/**
|
|
|
|
* Main entry point to be called directly from a wrapper program
|
|
|
|
* @param argc Argument count
|
|
|
|
* @param argv Argument array
|
|
|
|
* @param environ Environment variables
|
|
|
|
* @return Program exit code
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static int main(int argc, const char** argv, const char** environ);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Run the engine.
|
|
|
|
* @return Error code, 0 for success
|
|
|
|
*/
|
|
|
|
int run();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get a pointer to the unique instance.
|
|
|
|
* @return A pointer to the singleton instance of the engine
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static Engine* self();
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Register or unregister a plugin to the engine.
|
|
|
|
* @param plugin A pointer to the plugin to (un)register
|
|
|
|
* @param reg True to register (default), false to unregister
|
|
|
|
* @return True on success, false on failure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool Register(const Plugin* plugin, bool reg = true);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The configuration directory path
|
|
|
|
*/
|
2005-04-02 00:49:38 +00:00
|
|
|
static String configFile(const char* name);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* The configuration directory path
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline static String& configPath()
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return s_cfgpath; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The module loading path
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline static String& modulePath()
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return s_modpath; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The module suffix
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline static String& moduleSuffix()
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return s_modsuffix; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Reinitialize the plugins
|
|
|
|
*/
|
|
|
|
static void init();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Stop the engine and the entire program
|
|
|
|
* @param code Return code of the program
|
|
|
|
*/
|
|
|
|
static void halt(unsigned int code);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Check if the engine is currently exiting
|
|
|
|
* @return True if exiting, false in normal operation
|
|
|
|
*/
|
|
|
|
static bool exiting()
|
|
|
|
{ return (s_haltcode != -1); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Installs a handler in the dispatcher.
|
|
|
|
* @param handler A pointer to the handler to install
|
|
|
|
* @return True on success, false on failure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool install(MessageHandler* handler);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Uninstalls a handler drom the dispatcher.
|
|
|
|
* @param handler A pointer to the handler to uninstall
|
|
|
|
* @return True on success, false on failure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool uninstall(MessageHandler* handler);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Enqueue a message in the message queue
|
2004-12-08 00:04:26 +00:00
|
|
|
* @param msg The message to enqueue, will be destroyed after dispatching
|
2004-05-22 00:05:20 +00:00
|
|
|
* @return True if enqueued, false on error (already queued)
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool enqueue(Message* msg);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convenience function.
|
|
|
|
* Enqueue a new parameterless message in the message queue
|
2004-12-08 00:04:26 +00:00
|
|
|
* @param name Name of the parameterless message to put in queue
|
2004-05-22 00:05:20 +00:00
|
|
|
* @return True if enqueued, false on error (already queued)
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
inline static bool enqueue(const char* name)
|
2004-05-22 00:05:20 +00:00
|
|
|
{ return (name && *name) ? enqueue(new Message(name)) : false; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Dispatch a message to the registered handlers
|
|
|
|
* @param msg Pointer to the message to dispatch
|
|
|
|
* @return True if one handler accepted it, false if all ignored
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool dispatch(Message* msg);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Dispatch a message to the registered handlers
|
|
|
|
* @param msg The message to dispatch
|
|
|
|
* @return True if one handler accepted it, false if all ignored
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool dispatch(Message& msg);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convenience function.
|
|
|
|
* Dispatch a parameterless message to the registered handlers
|
|
|
|
* @param name The name of the message to create and dispatch
|
|
|
|
* @return True if one handler accepted it, false if all ignored
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
static bool dispatch(const char* name);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Install or remove a hook to catch messages after being dispatched
|
|
|
|
* @param hookFunc Pointer to a callback function
|
|
|
|
*/
|
|
|
|
inline void setHook(void (*hookFunc)(Message &, bool) = 0)
|
|
|
|
{ m_dispatcher.setHook(hookFunc); }
|
|
|
|
|
2004-11-01 00:07:00 +00:00
|
|
|
/**
|
|
|
|
* Get a count of plugins that are actively in use
|
|
|
|
* @return Count of plugins in use
|
|
|
|
*/
|
|
|
|
int usedPlugins();
|
|
|
|
|
2004-05-22 00:05:20 +00:00
|
|
|
protected:
|
|
|
|
/**
|
|
|
|
* Destroys the engine and everything. You must not call it directly,
|
|
|
|
* @ref run() will do it for you.
|
|
|
|
*/
|
|
|
|
~Engine();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Loads one plugin from a shared object file
|
|
|
|
* @return True if success, false on failure
|
|
|
|
*/
|
2005-03-20 03:11:53 +00:00
|
|
|
bool loadPlugin(const char* file);
|
2004-05-22 00:05:20 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Loads the plugins from the plugins directory
|
|
|
|
*/
|
|
|
|
void loadPlugins();
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Initialize all registered plugins
|
|
|
|
*/
|
|
|
|
void initPlugins();
|
|
|
|
|
|
|
|
private:
|
|
|
|
Engine();
|
|
|
|
ObjList m_libs;
|
|
|
|
MessageDispatcher m_dispatcher;
|
2005-03-20 03:11:53 +00:00
|
|
|
static Engine* s_self;
|
2004-05-22 00:05:20 +00:00
|
|
|
static String s_cfgpath;
|
|
|
|
static String s_cfgsuffix;
|
|
|
|
static String s_modpath;
|
|
|
|
static String s_modsuffix;
|
|
|
|
static int s_haltcode;
|
|
|
|
static int s_maxworkers;
|
|
|
|
static bool s_init;
|
|
|
|
static bool s_dynplugin;
|
|
|
|
};
|
|
|
|
|
|
|
|
}; // namespace TelEngine
|
|
|
|
|
2005-03-18 18:16:59 +00:00
|
|
|
#endif /* __YATENGINE_H */
|