yateclass.h

#ifndef __YATECLASS_H
#define __YATECLASS_H

#ifndef __cplusplus
#error C++ is required
#endif

#include <limits.h>
#include <sys/types.h>
#include <stddef.h>
#include <unistd.h>
#include <errno.h>
#include <stdarg.h>

#ifndef _WORDSIZE
#if defined(__arch64__) || defined(__x86_64__) \
    || defined(__amd64__) || defined(__ia64__) \
    || defined(__alpha__) || defined(__sparcv9) || defined(__mips64)
#define _WORDSIZE 64
#else
#define _WORDSIZE 32
#endif
#endif

#ifndef _WINDOWS
#if defined(WIN32) || defined(_WIN32)
#define _WINDOWS
#endif
#endif

#ifdef _WINDOWS

#include <windows.h>
#include <io.h>
#include <direct.h>

typedef signed __int8 int8_t;
typedef unsigned __int8 u_int8_t;
typedef unsigned __int8 uint8_t;
typedef signed __int16 int16_t;
typedef unsigned __int16 u_int16_t;
typedef unsigned __int16 uint16_t;
typedef signed __int32 int32_t;
typedef unsigned __int32 u_int32_t;
typedef unsigned __int32 uint32_t;
typedef signed __int64 int64_t;
typedef unsigned __int64 u_int64_t;
typedef unsigned __int64 uint64_t;

typedef int pid_t;
typedef int socklen_t;
typedef unsigned long in_addr_t;

#ifndef strcasecmp
#define strcasecmp _stricmp
#endif

#ifndef strncasecmp
#define strncasecmp _strnicmp
#endif

#define vsnprintf _vsnprintf
#define snprintf _snprintf
#define strdup _strdup
#define strtoll _strtoi64
#define open _open
#define dup2 _dup2
#define read _read
#define write _write
#define close _close
#define getpid _getpid
#define chdir _chdir
#define mkdir(p,m) _mkdir(p)
#define unlink _unlink

#define O_RDWR   _O_RDWR
#define O_RDONLY _O_RDONLY
#define O_WRONLY _O_WRONLY
#define O_APPEND _O_APPEND
#define O_BINARY _O_BINARY
#define O_EXCL   _O_EXCL
#define O_CREAT  _O_CREAT
#define O_TRUNC  _O_TRUNC
#define O_NOCTTY 0

#define S_IRUSR _S_IREAD
#define S_IWUSR _S_IWRITE
#define S_IXUSR 0
#define S_IRWXU (_S_IREAD|_S_IWRITE)

#ifdef LIBYATE_EXPORTS
#define YATE_API __declspec(dllexport)
#else
#ifndef LIBYATE_STATIC
#define YATE_API __declspec(dllimport)
#endif
#endif

#define FMT64 "%I64d"
#define FMT64U "%I64u"

#else /* _WINDOWS */

#include <sys/time.h>
#include <sys/socket.h>

#if defined(__FreeBSD__)
#include <netinet/in_systm.h>
#endif

#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>

#ifndef SOCKET
typedef int SOCKET;
#endif
#ifndef HANDLE
typedef int HANDLE;
#endif

#ifndef O_BINARY
#define O_BINARY 0
#endif

#if _WORDSIZE == 64 && !defined(__APPLE__)
#define FMT64 "%ld"
#define FMT64U "%lu"
#else
#define FMT64 "%lld"
#define FMT64U "%llu"
#endif

#endif /* ! _WINDOWS */

#ifndef LLONG_MAX
#ifdef _I64_MAX
#define LLONG_MAX _I64_MAX
#else
#define LLONG_MAX 9223372036854775807LL
#endif
#endif

#ifndef LLONG_MIN
#ifdef _I64_MIN
#define LLONG_MIN _I64_MIN
#else
#define LLONG_MIN (-LLONG_MAX - 1LL)
#endif
#endif

#ifndef ULLONG_MAX
#ifdef _UI64_MAX
#define ULLONG_MAX _UI64_MAX
#else
#define ULLONG_MAX 18446744073709551615ULL
#endif
#endif

#ifndef O_LARGEFILE
#define O_LARGEFILE 0
#endif

#ifndef IPTOS_LOWDELAY
#define IPTOS_LOWDELAY      0x10
#define IPTOS_THROUGHPUT    0x08
#define IPTOS_RELIABILITY   0x04
#endif
#ifndef IPTOS_MINCOST
#define IPTOS_MINCOST       0x02
#endif
#ifndef IPPROTO_SCTP
#define IPPROTO_SCTP        132
#endif

#ifndef YATE_API
#define YATE_API
#endif

#ifdef _WINDOWS
#undef RAND_MAX
#define RAND_MAX 2147483647
#endif

namespace TelEngine {

#ifdef HAVE_GCC_FORMAT_CHECK
#define FORMAT_CHECK(f) __attribute__((format(printf,(f),(f)+1)))
#else
#define FORMAT_CHECK(f)
#endif

#define YIGNORE(v) while (v) { break; }

#ifdef HAVE_BLOCK_RETURN
#define YSTRING(s) (*({static const String str("" s);&str;}))
#define YATOM(s) (*({static const String* str(0);str ? str : String::atom(str,"" s);}))
#else
#define YSTRING(s) ("" s)
#define YATOM(s) ("" s)
#endif

#define YSTRING_INIT_HASH ((unsigned) -1)

YATE_API void abortOnBug();

YATE_API bool abortOnBug(bool doAbort);

enum DebugLevel {
    DebugFail = 0,
    DebugTest = 1,
    DebugCrit = 2,
    DebugGoOn = DebugCrit,
    DebugConf = 3,
    DebugStub = 4,
    DebugWarn = 5,
    DebugMild = 6,
    DebugNote = 7,
    DebugCall = 8,
    DebugInfo = 9,
    DebugAll = 10
};

YATE_API int debugLevel();

YATE_API int debugLevel(int level);

YATE_API bool debugAt(int level);

YATE_API const char* debugColor(int level);

YATE_API const char* debugLevelName(int level);

class YATE_API DebugEnabler
{
public:
    inline DebugEnabler(int level = TelEngine::debugLevel(), bool enabled = true)
        : m_level(DebugFail), m_enabled(enabled), m_chain(0), m_name(0)
        { debugLevel(level); }

    inline ~DebugEnabler()
        { m_name = 0; m_chain = 0; }

    inline int debugLevel() const
        { return m_chain ? m_chain->debugLevel() : m_level; }

    int debugLevel(int level);

    inline bool debugEnabled() const
        { return m_chain ? m_chain->debugEnabled() : m_enabled; }

    inline void debugEnabled(bool enable)
        { m_enabled = enable; m_chain = 0; }

    inline const char* debugName() const
        { return m_name; }

    bool debugAt(int level) const;

    inline bool debugChained() const
        { return m_chain != 0; }

    inline void debugChain(const DebugEnabler* chain = 0)
        { m_chain = (chain != this) ? chain : 0; }

    void debugCopy(const DebugEnabler* original = 0);

protected:
    inline void debugName(const char* name)
        { m_name = name; }

private:
    int m_level;
    bool m_enabled;
    const DebugEnabler* m_chain;
    const char* m_name;
};

#if 0 /* for documentation generator */

void DDebug(int level, const char* format, ...);

void DDebug(const char* facility, int level, const char* format, ...);

void DDebug(const DebugEnabler* local, int level, const char* format, ...);

void XDebug(int level, const char* format, ...);

void XDebug(const char* facility, int level, const char* format, ...);

void XDebug(const DebugEnabler* local, int level, const char* format, ...);

void NDebug(int level, const char* format, ...);

void NDebug(const char* facility, int level, const char* format, ...);

void NDebug(const DebugEnabler* local, int level, const char* format, ...);
#endif

#if defined(_DEBUG) || defined(DEBUG) || defined(XDEBUG)
#undef DEBUG
#define DEBUG   1
#endif

#ifdef DEBUG
#define DDebug Debug
#else
#ifdef _WINDOWS
#define DDebug do { break; } while
#else
#define DDebug(arg...)
#endif
#endif

#ifdef XDEBUG
#define XDebug Debug
#else
#ifdef _WINDOWS
#define XDebug do { break; } while
#else
#define XDebug(arg...)
#endif
#endif

#ifndef NDEBUG
#define NDebug Debug
#else
#ifdef _WINDOWS
#define NDebug do { break; } while
#else
#define NDebug(arg...)
#endif
#endif

YATE_API void Debug(int level, const char* format, ...) FORMAT_CHECK(2);

YATE_API void Debug(const char* facility, int level, const char* format, ...) FORMAT_CHECK(3);

YATE_API void Debug(const DebugEnabler* local, int level, const char* format, ...) FORMAT_CHECK(3);

YATE_API void Alarm(const char* component, int level, const char* format, ...) FORMAT_CHECK(3);

YATE_API void Alarm(const DebugEnabler* component, int level, const char* format, ...) FORMAT_CHECK(3);

YATE_API void Alarm(const char* component, const char* info, int level, const char* format, ...) FORMAT_CHECK(4);

YATE_API void Alarm(const DebugEnabler* component, const char* info, int level, const char* format, ...) FORMAT_CHECK(4);

YATE_API void Output(const char* format, ...) FORMAT_CHECK(1);

class YATE_API Debugger
{
public:
    enum Formatting {
        None = 0,
        Relative,  // from program start
        Absolute,  // from EPOCH (1-1-1970)
        Textual,   // absolute GMT in YYYYMMDDhhmmss.uuuuuu format
        TextLocal, // local time in YYYYMMDDhhmmss.uuuuuu format
        TextSep,   // absolute GMT in YYYY-MM-DD_hh:mm:ss.uuuuuu format
        TextLSep,  // local time in YYYY-MM-DD_hh:mm:ss.uuuuuu format
    };

    explicit Debugger(const char* name, const char* format = 0, ...);

    Debugger(int level, const char* name, const char* format = 0, ...);

    ~Debugger();

    static void setOutput(void (*outFunc)(const char*,int) = 0);

    static void setIntOut(void (*outFunc)(const char*,int) = 0);

    static void setAlarmHook(void (*alarmFunc)(const char*,int,const char*,const char*) = 0);

    static void setRelayHook(void (*relayFunc)(int,const char*,const char*,const char*) = 0);

    static void enableOutput(bool enable = true, bool colorize = false);

    static uint32_t getStartTimeSec();

    static Formatting getFormatting();

    static void setFormatting(Formatting format, uint32_t startTimeSec = 0);

    static unsigned int formatTime(char* buf, Formatting format = getFormatting());

    static void relayOutput(int level, char* buffer, const char* component = 0, const char* info = 0);

private:
    const char* m_name;
    int m_level;
};

struct TokenDict {
    const char* token;

    int value;
};

class String;
class Mutex;
class ObjList;
class NamedCounter;

#if 0 /* for documentation generator */

void YIGNORE(primitive value);

constant YSTRING(const char* string);

constant YATOM(const char* string);

void YCLASS(class type,class base);

void YCLASS2(class type,class base1,class base2);

void YCLASS3(class type,class base1,class base2,class base3);

void YCLASSIMP(class type,class base);

void YCLASSIMP2(class type,class base1,class base2);

void YCLASSIMP3(class type,class base1,class base2,class base3);

class* YOBJECT(class type,GenObject* pntr);

void YNOCOPY(class type);
#endif

#define YCLASS(type,base) \
public: virtual void* getObject(const String& name) const \
{ return (name == YATOM(#type)) ? const_cast<type*>(this) : base::getObject(name); }

#define YCLASS2(type,base1,base2) \
public: virtual void* getObject(const String& name) const \
{ if (name == YATOM(#type)) return const_cast<type*>(this); \
  void* tmp = base1::getObject(name); \
  return tmp ? tmp : base2::getObject(name); }

#define YCLASS3(type,base1,base2,base3) \
public: virtual void* getObject(const String& name) const \
{ if (name == YATOM(#type)) return const_cast<type*>(this); \
  void* tmp = base1::getObject(name); \
  if (tmp) return tmp; \
  tmp = base2::getObject(name); \
  return tmp ? tmp : base3::getObject(name); }

#define YCLASSIMP(type,base) \
void* type::getObject(const String& name) const \
{ return (name == YATOM(#type)) ? const_cast<type*>(this) : base::getObject(name); }

#define YCLASSIMP2(type,base1,base2) \
void* type::getObject(const String& name) const \
{ if (name == YATOM(#type)) return const_cast<type*>(this); \
  void* tmp = base1::getObject(name); \
  return tmp ? tmp : base2::getObject(name); }

#define YCLASSIMP3(type,base1,base2,base3) \
void* type::getObject(const String& name) const \
{ if (name == YATOM(#type)) return const_cast<type*>(this); \
  void* tmp = base1::getObject(name); \
  if (tmp) return tmp; \
  tmp = base2::getObject(name); \
  return tmp ? tmp : base3::getObject(name); }

#define YOBJECT(type,pntr) (static_cast<type*>(GenObject::getObject(YATOM(#type),pntr)))

#define YNOCOPY(type) private: \
type(const type&); \
void operator=(const type&)


class YATE_API GenObject
{
    YNOCOPY(GenObject); // no automatic copies please
public:
    GenObject();

    virtual ~GenObject() { setObjCounter(0); }

    virtual bool alive() const;

    virtual void destruct();

    virtual const String& toString() const;

    virtual void* getObject(const String& name) const;

    static inline void* getObject(const String& name, const GenObject* obj)
        { return obj ? obj->getObject(name) : 0; }

    static inline bool getObjCounting()
        { return s_counting; }

    static inline void setObjCounting(bool enable)
        { s_counting = enable; }

    inline NamedCounter* getObjCounter() const
        { return m_counter; }

    NamedCounter* setObjCounter(NamedCounter* counter);

    static NamedCounter* getObjCounter(const String& name, bool create = true);

    static ObjList& getObjCounters();

private:
    NamedCounter* m_counter;
    static bool s_counting;
};

inline void destruct(GenObject* obj)
    { if (obj) obj->destruct(); }

template <class Obj> void destruct(Obj*& obj)
    { if (obj) { obj->destruct(); obj = 0; } }

class YATE_API RefObject : public GenObject
{
    YNOCOPY(RefObject); // no automatic copies please
public:
    RefObject();

    virtual ~RefObject();

    virtual void* getObject(const String& name) const;

    virtual bool alive() const;

    bool ref();

    bool deref();

    inline int refcount() const
        { return m_refcount; }

    virtual void destruct();

    inline static bool alive(const RefObject* obj)
        { return obj && (obj->refcount() > 0); }

    static bool efficientIncDec();

protected:
    virtual void zeroRefs();

    bool resurrect();

    virtual void destroyed();

private:
    int m_refcount;
    Mutex* m_mutex;
};

class YATE_API RefPointerBase
{
protected:
    inline RefPointerBase()
        : m_pointer(0) { }

    void assign(RefObject* oldptr, RefObject* newptr, void* pointer);

    void* m_pointer;
};

template <class Obj = RefObject> class RefPointer : public RefPointerBase
{
protected:
    inline Obj* pointer() const
        { return static_cast<Obj*>(m_pointer); }

    inline void assign(Obj* object = 0)
        { RefPointerBase::assign(pointer(),object,object); }

public:
    inline RefPointer()
        { }

    inline RefPointer(const RefPointer<Obj>& value)
        : RefPointerBase()
        { assign(value); }

    inline RefPointer(Obj* object)
        { assign(object); }

    inline ~RefPointer()
        { assign(); }

    inline RefPointer<Obj>& operator=(const RefPointer<Obj>& value)
        { assign(value.pointer()); return *this; }

    inline RefPointer<Obj>& operator=(Obj* object)
        { assign(object); return *this; }

    inline operator Obj*() const
        { return pointer(); }

    inline Obj* operator->() const
        { return pointer(); }

    inline Obj& operator*() const
        { return *pointer(); }
};

template <class Obj = GenObject> class GenPointer : public GenObject
{
private:
    Obj* m_pointer;

public:
    inline GenPointer()
        : m_pointer(0)
        { }

    inline GenPointer(const GenPointer<Obj>& value)
        : m_pointer(value)
        { }

    inline GenPointer(Obj* object)
        : m_pointer(object)
        { }

    inline GenPointer<Obj>& operator=(const GenPointer<Obj>& value)
        { m_pointer = value; return *this; }

    inline GenPointer<Obj>& operator=(Obj* object)
        { m_pointer = object; return *this; }

    inline operator Obj*() const
        { return m_pointer; }

    inline Obj* operator->() const
        { return m_pointer; }

    inline Obj& operator*() const
        { return *m_pointer; }
};

class YATE_API ObjList : public GenObject
{
    YNOCOPY(ObjList); // no automatic copies please
public:
    ObjList();

    virtual ~ObjList();

    virtual void* getObject(const String& name) const;

    unsigned int length() const;

    unsigned int count() const;

    inline GenObject* get() const
        { return m_obj; }

    GenObject* set(const GenObject* obj, bool delold = true);

    inline ObjList* next() const
        { return m_next; }

    ObjList* last() const;

    ObjList* skipNull() const;

    ObjList* skipNext() const;

    GenObject* at(int index) const;

    ObjList* operator+(int index) const;

    inline GenObject* operator[](signed int index) const
        { return at(index); }

    inline GenObject* operator[](unsigned int index) const
        { return at(index); }

    GenObject* operator[](const String& str) const;

    ObjList* find(const GenObject* obj) const;

    ObjList* find(const String& str) const;

    int index(const GenObject* obj) const;

    int index(const String& str) const;

    ObjList* insert(const GenObject* obj, bool compact = true);

    ObjList* append(const GenObject* obj, bool compact = true);

    ObjList* setUnique(const GenObject* obj, bool compact = true);

    GenObject* remove(bool delobj = true);

    GenObject* remove(GenObject* obj, bool delobj = true);

    GenObject* remove(const String& str, bool delobj = true);

    void clear();

    void compact();

    inline bool autoDelete()
        { return m_delete; }

    inline void setDelete(bool autodelete)
        { m_delete = autodelete; }

    static const ObjList& empty();

    void sort(int (*callbackCompare)(GenObject* obj1, GenObject* obj2, void* context), void* context = 0);
private:
    ObjList* m_next;
    GenObject* m_obj;
    bool m_delete;
};

class YATE_API ObjVector : public GenObject
{
    YNOCOPY(ObjVector); // no automatic copies please
public:
    inline explicit ObjVector(bool autodelete = true)
        : m_length(0), m_objects(0), m_delete(autodelete)
        { }

    ObjVector(unsigned int maxLen, bool autodelete = true);

    ObjVector(ObjList& list, bool move = true, unsigned int maxLen = 0, bool autodelete = true);

    virtual ~ObjVector();

    virtual void* getObject(const String& name) const;

    inline unsigned int length() const
        { return m_length; }

    unsigned int count() const;

    bool null() const;

    inline GenObject* at(int index) const
        { return (index >= 0 && index < (int)m_length) ? m_objects[index] : 0; }

    inline GenObject* operator[](signed int index) const
        { return at(index); }

    inline GenObject* operator[](unsigned int index) const
        { return at(index); }

    unsigned int assign(ObjList& list, bool move = true, unsigned int maxLen = 0);

    GenObject* take(unsigned int index);

    bool set(GenObject* obj, unsigned int index);

    int index(const GenObject* obj) const;

    int index(const String& str) const;

    void clear();

    inline bool autoDelete()
        { return m_delete; }

    inline void setDelete(bool autodelete)
        { m_delete = autodelete; }

private:
    unsigned int m_length;
    GenObject** m_objects;
    bool m_delete;
};

class YATE_API Array : public RefObject
{
public:
    explicit Array(int columns = 0, int rows = 0);

    virtual ~Array();

    virtual void* getObject(const String& name) const;

    bool addRow(ObjList* row = 0, int index = -1);

    bool addColumn(ObjList* column = 0, int index = -1);

    bool delRow(int index);

    bool delColumn(int index);

    GenObject* get(int column, int row) const;

    GenObject* take(int column, int row);

    bool set(GenObject* obj, int column, int row);

    inline int getRows() const
        { return m_rows; }

    inline int getColumns() const
        { return m_columns; }

    inline ObjList* getColumn(int column) const {
            if (column >= 0 || column < m_columns)
                return static_cast<ObjList*>(m_obj[column]);
            return 0;
        }

private:
    int m_rows;
    int m_columns;
    ObjList m_obj;
};

class Regexp;
class StringMatchPrivate;

class YATE_API UChar
{
public:
    inline explicit UChar(uint32_t code = 0)
        : m_chr(code)
        { encode(); }

    inline explicit UChar(int32_t code)
        : m_chr((code < 0) ? 0 : code)
        { encode(); }

    inline explicit UChar(signed char code)
        : m_chr((unsigned char)code)
        { encode(); }

    inline explicit UChar(unsigned char code)
        : m_chr(code)
        { encode(); }

    inline UChar& operator=(uint32_t code)
        { m_chr = code; encode(); return *this; }

    inline UChar& operator=(char code)
        { m_chr = (unsigned char)code; encode(); return *this; }

    inline uint32_t code() const
        { return m_chr; }

    inline const char* c_str() const
        { return m_str; }

    inline operator const char*() const
        { return m_str; };

    bool decode(const char*& str, uint32_t maxChar = 0x10ffff, bool overlong = false);

private:
    void encode();
    uint32_t m_chr;
    char m_str[8];
};

class YATE_API String : public GenObject
{
public:
    enum Align {
        Left = 0,
        Center,
        Right
    };

    String();

    String(const char* value, int len = -1);

    explicit String(char value, unsigned int repeat = 1);

    explicit String(int32_t value);

    explicit String(uint32_t value);

    explicit String(int64_t value);

    explicit String(uint64_t value);

    explicit String(bool value);

    explicit String(double value);

    String(const String& value);

    String(const String* value);

    virtual ~String();

    virtual void* getObject(const String& name) const;

    static const String& empty();

    inline static const char* boolText(bool value)
        { return value ? "true" : "false"; }

    inline const char* c_str() const
        { return m_string; }

    inline const char* safe() const
        { return m_string ? m_string : ""; }

    inline const char* safe(const char* defStr) const
        { return m_string ? m_string : (defStr ? defStr : ""); }

    inline unsigned int length() const
        { return m_length; }

    inline bool null() const
        { return !m_string; }

    static int lenUtf8(const char* value, uint32_t maxChar = 0x10ffff, bool overlong = false);

    inline int lenUtf8(uint32_t maxChar = 0x10ffff, bool overlong = false) const
        { return lenUtf8(m_string,maxChar,overlong); }


    int fixUtf8(const char* replace = 0, uint32_t maxChar = 0x10ffff, bool overlong = false);

    inline static bool checkBOM(const char* str)
        { return str && (str[0] == '\357') && (str[1] == '\273') && (str[2] == '\277'); }

    inline bool checkBOM() const
        { return checkBOM(c_str()); }

    inline static bool stripBOM(const char*& str)
        { return checkBOM(str) && (str += 3); }

    inline static bool stripBOM(char*& str)
        { return checkBOM(str) && (str += 3); }

    inline bool stripBOM()
        { return checkBOM(c_str()) && &(*this = c_str() + 3); }

    inline unsigned int hash() const
        {
            if (m_hash == YSTRING_INIT_HASH)
                m_hash = hash(m_string);
            return m_hash;
        }

    static unsigned int hash(const char* value, unsigned int h = 0);

    void clear();

    char at(int index) const;

    String substr(int offs, int len = -1) const;

    String& trimBlanks();

    String& trimSpaces();

    virtual const String& toString() const;

    int toInteger(int defvalue = 0, int base = 0, int minvalue = INT_MIN,
        int maxvalue = INT_MAX, bool clamp = true) const;

    int toInteger(const TokenDict* tokens, int defvalue = 0, int base = 0) const;

    long int toLong(long int defvalue = 0, int base = 0, long int minvalue = LONG_MIN,
        long int maxvalue = LONG_MAX, bool clamp = true) const;

    int64_t toInt64(int64_t defvalue = 0, int base = 0, int64_t minvalue = LLONG_MIN,
        int64_t maxvalue = LLONG_MAX, bool clamp = true) const;

    double toDouble(double defvalue = 0.0) const;

    bool toBoolean(bool defvalue = false) const;

    bool isBoolean() const;

    String& toUpper();

    String& toLower();

    inline char operator[](signed int index) const
        { return at(index); }

    inline char operator[](unsigned int index) const
        { return at(index); }

    inline operator const char*() const
        { return m_string; };

    String& assign(const char* value, int len = -1);

    String& assign(char value, unsigned int repeat = 1);

    String& hexify(void* data, unsigned int len, char sep = 0, bool upCase = false);

    inline String& operator=(const String& value)
        { return operator=(value.c_str()); }

    inline String& operator=(const String* value)
        { return operator=(value ? value->c_str() : ""); }

    String& operator=(const char* value);

    String& operator=(char value);

    String& operator=(int32_t value);

    String& operator=(uint32_t value);

    String& operator=(int64_t value);

    String& operator=(uint64_t value);

    inline String& operator=(bool value)
        { return operator=(boolText(value)); }

    String& operator=(double value);

    inline String& operator+=(const char* value)
        { return append(value,-1); }

    String& operator+=(char value);

    String& operator+=(int32_t value);

    String& operator+=(uint32_t value);

    String& operator+=(int64_t value);

    String& operator+=(uint64_t value);

    inline String& operator+=(bool value)
        { return operator+=(boolText(value)); }

    String& operator+=(double value);

    bool operator==(const char* value) const;

    bool operator!=(const char* value) const;

    inline bool operator==(const String& value) const
        { return (this == &value) || ((hash() == value.hash()) && operator==(value.c_str())); }

    inline bool operator!=(const String& value) const
        { return (this != &value) && ((hash() != value.hash()) || operator!=(value.c_str())); }

    bool operator&=(const char* value) const;

    bool operator|=(const char* value) const;

    inline String& operator<<(const char* value)
        { return operator+=(value); }

    inline String& operator<<(char value)
        { return operator+=(value); }

    inline String& operator<<(int32_t value)
        { return operator+=(value); }

    inline String& operator<<(uint32_t value)
        { return operator+=(value); }

    inline String& operator<<(int64_t value)
        { return operator+=(value); }

    inline String& operator<<(uint64_t value)
        { return operator+=(value); }

    inline String& operator<<(bool value)
        { return operator+=(value); }

    inline String& operator<<(double value)
        { return operator+=(value); }

    String& operator>>(const char* skip);

    String& operator>>(char& store);

    String& operator>>(UChar& store);

    String& operator>>(int& store);

    String& operator>>(unsigned int& store);

    String& operator>>(bool& store);

    String& append(const char* value, int len);

    String& append(const char* value, const char* separator = 0, bool force = false);

    String& append(const ObjList* list, const char* separator = 0, bool force = false);

    inline String& append(const ObjList& list, const char* separator = 0, bool force = false)
        { return append(&list,separator,force); }

    String& append(double value, unsigned int decimals = 3);

    String& printf(const char* format, ...) FORMAT_CHECK(2);

    String& printf(unsigned int length, const char* format,  ...) FORMAT_CHECK(3);

    String& appendFixed(unsigned int fixedLength, const char* str, unsigned int len = -1, char fill = ' ', int align = Left);

    inline String& appendFixed(unsigned int fixedLength, const String& str, char fill = ' ', int align = Left)
        { return appendFixed(fixedLength,str.c_str(),str.length(),fill,align); }

    int find(char what, unsigned int offs = 0) const;

    int find(const char* what, unsigned int offs = 0) const;

    int rfind(char what) const;

    int rfind(const char* what) const;

    bool startsWith(const char* what, bool wordBreak = false, bool caseInsensitive = false) const;

    bool endsWith(const char* what, bool wordBreak = false, bool caseInsensitive = false) const;

    bool startSkip(const char* what, bool wordBreak = true, bool caseInsensitive = false);

    String& extractTo(const char* sep, String& store);

    String& extractTo(const char* sep, bool& store);

    String& extractTo(const char* sep, int& store, int base = 0);

    String& extractTo(const char* sep, int& store, const TokenDict* tokens, int base = 0);

    String& extractTo(const char* sep, double& store);

    virtual bool matches(const String& value) const
        { return operator==(value); }

    bool matches(const Regexp& rexp);

    int matchOffset(int index = 0) const;

    int matchLength(int index = 0) const;

    inline String matchString(int index = 0) const
        { return substr(matchOffset(index),matchLength(index)); }

    String replaceMatches(const String& templ) const;

    int matchCount() const;

    ObjList* split(char separator, bool emptyOK = true) const;

    static String msgEscape(const char* str, char extraEsc = 0);

    inline String msgEscape(char extraEsc = 0) const
        { return msgEscape(c_str(),extraEsc); }

    static String msgUnescape(const char* str, int* errptr = 0, char extraEsc = 0);

    inline String msgUnescape(int* errptr = 0, char extraEsc = 0) const
        { return msgUnescape(c_str(),errptr,extraEsc); }

    static String sqlEscape(const char* str, char extraEsc = 0);

    inline String sqlEscape(char extraEsc = 0) const
        { return sqlEscape(c_str(),extraEsc); }

    static String uriEscape(const char* str, char extraEsc = 0, const char* noEsc = 0);

    static String uriEscape(const char* str, const char* extraEsc, const char* noEsc = 0);

    inline String uriEscape(char extraEsc = 0, const char* noEsc = 0) const
        { return uriEscape(c_str(),extraEsc,noEsc); }

    static String uriUnescape(const char* str, int* errptr = 0);

    inline String uriUnescape(int* errptr = 0) const
        { return uriUnescape(c_str(),errptr); }

    static const String* atom(const String*& str, const char* val);

protected:
     virtual void changed();

private:
    void clearMatches();
    char* m_string;
    unsigned int m_length;
    // I hope every C++ compiler now knows about mutable...
    mutable unsigned int m_hash;
    StringMatchPrivate* m_matches;
};

inline const char* c_str(const String* str)
    { return str ? str->c_str() : (const char*)0; }

inline const char* c_safe(const char* str)
    { return str ? str : ""; }

inline const char* c_safe(const String* str)
    { return str ? str->safe() : ""; }

inline bool null(const char* str)
    { return !(str && *str); }

inline bool null(const String* str)
    { return !str || str->null(); }

YATE_API String operator+(const String& s1, const String& s2);

YATE_API String operator+(const String& s1, const char* s2);

YATE_API String operator+(const char* s1, const String& s2);

inline const char *strcpy(String& dest, const char* src)
    { dest = src; return dest.c_str(); }

inline const char *strcat(String& dest, const char* src)
    { dest += src; return dest.c_str(); }

YATE_API int lookup(const char* str, const TokenDict* tokens, int defvalue = 0, int base = 0);

YATE_API const char* lookup(int value, const TokenDict* tokens, const char* defvalue = 0);

class NamedList;

YATE_API bool controlReturn(NamedList* params, bool ret, const char* retVal = 0);

class YATE_API Regexp : public String
{
    friend class String;
public:
    Regexp();

    explicit Regexp(const char* value, bool extended = false, bool insensitive = false);

    Regexp(const Regexp& value);

    virtual ~Regexp();

    inline Regexp& operator=(const char* value)
        { String::operator=(value); return *this; }

    inline bool compile() const
        { return m_regexp || (m_compile && doCompile()); }

    bool matches(const char* value) const;

    virtual bool matches(const String& value) const
        { return Regexp::matches(value.safe()); }

    void setFlags(bool extended, bool insensitive);

    bool isExtended() const;

    bool isCaseInsensitive() const;

protected:
    virtual void changed();

    bool doCompile() const;

private:
    void cleanup();
    bool matches(const char* value, StringMatchPrivate* matchlist) const;
    mutable void* m_regexp;
    mutable bool m_compile;
    int m_flags;
};

class Atom
{
public:
    inline explicit Atom(const char* value)
        : m_atom(0)
        { String::atom(m_atom,value); }

    inline operator const String&() const
        { return *m_atom; }

    inline const String* operator->() const
        { return m_atom; }

private:
    const String* m_atom;
};

class YATE_API CapturedEvent : public String
{
    friend class Engine;
    YCLASS(CapturedEvent,String)
public:
    inline CapturedEvent(int level, const char* text)
        : String(text), m_level(level)
        { }

    inline CapturedEvent(const CapturedEvent& original)
        : String(original), m_level(original.level())
        { }

    inline int level() const
        { return m_level; }


    inline static bool capturing()
        { return s_capturing; }

    inline static const ObjList& events()
        { return s_events; }

    inline static void append(int level, const char* text)
        { if (text && *text) s_events.append(new CapturedEvent(level,text)); }

protected:
    inline static ObjList& eventsRw()
        { return s_events; }

    inline static void capturing(bool capture)
        { s_capturing = capture; }

private:
    int m_level;
    static ObjList s_events;
    static bool s_capturing;
};

class YATE_API NamedString : public String
{
    YNOCOPY(NamedString); // no automatic copies please
public:
    explicit NamedString(const char* name, const char* value = 0);

    inline const String& name() const
        { return m_name; }

    virtual const String& toString() const;

    virtual void* getObject(const String& name) const;

    inline NamedString& operator=(const char* value)
        { String::operator=(value); return *this; }

private:
    NamedString(); // no default constructor please
    String m_name;
};

class YATE_API NamedPointer : public NamedString
{
public:
    explicit NamedPointer(const char* name, GenObject* data = 0, const char* value = 0);

    virtual ~NamedPointer();

    inline GenObject* userData() const
        { return m_data; }

    GenObject* takeData();

    void userData(GenObject* data);

    inline void* userObject(const String& name) const
        { return m_data ? m_data->getObject(name) : 0; }

    inline NamedPointer& operator=(const char* value)
        { NamedString::operator=(value); return *this; }

    virtual void* getObject(const String& name) const;

protected:
    virtual void changed();

private:
    NamedPointer(); // no default constructor please
    GenObject* m_data;
};

class YATE_API NamedCounter : public String
{
    YNOCOPY(NamedCounter); // no automatic copies please
public:
    explicit NamedCounter(const String& name);

    inline bool enabled() const
        { return m_enabled; }

    inline void enable(bool val)
        { m_enabled = val; }

    int inc();

    int dec();

    inline int count() const
        { return m_count; }

private:
    int m_count;
    bool m_enabled;
    Mutex* m_mutex;
};

class YATE_API HashList : public GenObject
{
    YNOCOPY(HashList); // no automatic copies please
public:
    explicit HashList(unsigned int size = 17);

    virtual ~HashList();

    virtual void* getObject(const String& name) const;

    inline unsigned int length() const
        { return m_size; }

    unsigned int count() const;

    inline ObjList* getList(unsigned int index) const
        { return (index < m_size) ? m_lists[index] : 0; }

    inline ObjList* getHashList(unsigned int hash) const
        { return getList(hash % m_size); }

    inline ObjList* getHashList(const String& str) const
        { return getHashList(str.hash()); }

    GenObject* operator[](const String& str) const;

    ObjList* find(const GenObject* obj) const;

    ObjList* find(const GenObject* obj, unsigned int hash) const;

    ObjList* find(const String& str) const;

    ObjList* append(const GenObject* obj);

    GenObject* remove(GenObject* obj, bool delobj = true, bool useHash = false);

    inline GenObject* remove(const String& str, bool delobj = true)
    {
        ObjList* n = find(str);
        return n ? n->remove(delobj) : 0;
    }

    void clear();

    bool resync(GenObject* obj);

    bool resync();

private:
    unsigned int m_size;
    ObjList** m_lists;
};

class YATE_API ListIterator
{
    YNOCOPY(ListIterator); // no automatic copies please
public:
    ListIterator(ObjList& list, int offset = 0);

    ListIterator(HashList& list, int offset = 0);

    ~ListIterator();

    inline unsigned int length() const
        { return m_length; }

    void clear();

    void assign(ObjList& list, int offset = 0);

    void assign(HashList& list, int offset = 0);

    GenObject* get(unsigned int index) const;

    GenObject* get();

    inline bool eof() const
        { return m_current >= m_length; }

    inline void reset()
        { m_current = 0; }

private:
    ObjList* m_objList;
    HashList* m_hashList;
    GenObject** m_objects;
    unsigned int* m_hashes;
    unsigned int m_length;
    unsigned int m_current;
};

class YATE_API Time
{
public:
    inline Time()
        : m_time(now())
        { }

    inline Time(u_int64_t usec)
        : m_time(usec)
        { }

    inline explicit Time(const struct timeval* tv)
        : m_time(fromTimeval(tv))
        { }

    inline explicit Time(const struct timeval& tv)
        : m_time(fromTimeval(tv))
        { }

    inline ~Time()
        { }

    inline u_int32_t sec() const
        { return (u_int32_t)((m_time+500000) / 1000000); }

    inline u_int64_t msec() const
        { return (m_time+500) / 1000; }

    inline u_int64_t usec() const
        { return m_time; }

    inline operator u_int64_t() const
        { return m_time; }

    inline Time& operator=(u_int64_t usec)
        { m_time = usec; return *this; }

    inline Time& operator+=(int64_t delta)
        { m_time += delta; return *this; }

    inline Time& operator-=(int64_t delta)
        { m_time -= delta; return *this; }

    inline void toTimeval(struct timeval* tv) const
        { toTimeval(tv, m_time); }

    static void toTimeval(struct timeval* tv, u_int64_t usec);

    static u_int64_t fromTimeval(const struct timeval* tv);

    inline static u_int64_t fromTimeval(const struct timeval& tv)
        { return fromTimeval(&tv); }

    static u_int64_t now();

    static u_int64_t msecNow();

    static u_int32_t secNow();

    static unsigned int toEpoch(int year, unsigned int month, unsigned int day,
        unsigned int hour, unsigned int minute, unsigned int sec, int offset = 0);

    static bool toDateTime(unsigned int epochTimeSec, int& year, unsigned int& month,
        unsigned int& day, unsigned int& hour, unsigned int& minute, unsigned int& sec,
        unsigned int* wDay = 0);

    static inline bool isLeap(unsigned int year)
        { return (year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)); }

    static int timeZone();

private:
    u_int64_t m_time;
};

class YATE_API Random
{
public:
    inline Random(u_int32_t seed = Time::now() & 0xffffffff)
        : m_random(seed)
        { }

    inline u_int32_t get() const
        { return m_random; }

    inline void set(u_int32_t seed)
        { m_random = seed; }

    u_int32_t next();

    static long int random();

    static void srandom(unsigned int seed);

private:
    u_int32_t m_random;
};

class YATE_API DataBlock : public GenObject
{
public:

    DataBlock(unsigned int overAlloc = 0);

    DataBlock(const DataBlock& value);

    DataBlock(const DataBlock& value, unsigned int overAlloc);

    DataBlock(void* value, unsigned int len, bool copyData = true, unsigned int overAlloc = 0);

    virtual ~DataBlock();

    virtual void* getObject(const String& name) const;

    static const DataBlock& empty();

    inline void* data() const
        { return m_data; }

    inline unsigned char* data(unsigned int offs, unsigned int len = 1) const
        { return (offs + len <= m_length) ? (static_cast<unsigned char*>(m_data) + offs) : 0; }

    inline int at(unsigned int offs, int defvalue = -1) const
        { return (offs < m_length) ? static_cast<unsigned char*>(m_data)[offs] : defvalue; }

    inline bool null() const
        { return !m_data; }

    inline unsigned int length() const
        { return m_length; }

    inline unsigned int overAlloc() const
        { return m_overAlloc; }

    inline void overAlloc(unsigned int bytes)
        { m_overAlloc = bytes; }

    void clear(bool deleteData = true);

    DataBlock& assign(void* value, unsigned int len, bool copyData = true, unsigned int allocated = 0);

    inline void append(void* value, unsigned int len) {
            DataBlock tmp(value,len,false);
            append(tmp);
            tmp.clear(false);
        }

    void append(const DataBlock& value);

    void append(const String& value);

    void insert(const DataBlock& value);

    inline void resize(unsigned int len) {
            if (len != length())
                assign(0,len);
        }

    void truncate(unsigned int len);

    void cut(int len);

    inline int operator[](signed int index) const
        { return at(index); }

    inline int operator[](unsigned int index) const
        { return at(index); }

    DataBlock& operator=(const DataBlock& value);

    inline DataBlock& operator+=(const DataBlock& value)
        { append(value); return *this; }

    inline DataBlock& operator+=(const String& value)
        { append(value); return *this; }

    bool convert(const DataBlock& src, const String& sFormat,
        const String& dFormat, unsigned maxlen = 0);

    bool unHexify(const char* data, unsigned int len, char sep);

    bool unHexify(const char* data, unsigned int len);

    inline bool unHexify(const String& data)
        { return unHexify(data.c_str(),data.length()); }

    String sqlEscape(char extraEsc) const;

private:
    unsigned int allocLen(unsigned int len) const;
    void* m_data;
    unsigned int m_length;
    unsigned int m_allocated;
    unsigned int m_overAlloc;
};

class YATE_API Hasher
{
public:
    virtual ~Hasher();

    virtual void clear() = 0;

    virtual void finalize() = 0;

    virtual const unsigned char* rawDigest() = 0;

    inline const String& hexDigest()
        { finalize(); return m_hex; }

    inline bool update(const void* buf, unsigned int len)
        { return updateInternal(buf,len); }

    inline bool update(const DataBlock& data)
        { return updateInternal(data.data(), data.length()); }

    inline bool update(const String& str)
        { return updateInternal(str.c_str(), str.length()); }

    inline Hasher& operator<<(const String& value)
        { update(value); return *this; }

    inline Hasher& operator<<(const DataBlock& data)
        { update(data); return *this; }

    Hasher& operator<<(const char* value);

    bool hmacStart(DataBlock& opad, const void* key, unsigned int keyLen);

    inline bool hmacStart(DataBlock& opad, const DataBlock& key)
        { return hmacStart(opad,key.data(),key.length()); }

    inline bool hmacStart(DataBlock& opad, const String& key)
        { return hmacStart(opad,key.c_str(),key.length()); }

    bool hmacFinal(const DataBlock& opad);

    bool hmac(const void* key, unsigned int keyLen, const void* msg, unsigned int msgLen);

    inline bool hmac(const DataBlock& key, const DataBlock& msg)
        { return hmac(key.data(),key.length(),msg.data(),msg.length()); }

    inline bool hmac(const String& key, const String& msg)
        { return hmac(key.c_str(),key.length(),msg.c_str(),msg.length()); }

    virtual unsigned int hashLength() const = 0;

    virtual unsigned int hmacBlockSize() const;

protected:
    inline Hasher()
        : m_private(0)
        { }

    virtual bool updateInternal(const void* buf, unsigned int len) = 0;

    void* m_private;
    String m_hex;
};

class YATE_API MD5 : public Hasher
{
public:
    MD5();

    MD5(const MD5& original);

    MD5(const void* buf, unsigned int len);

    MD5(const DataBlock& data);

    MD5(const String& str);

    MD5& operator=(const MD5& original);

    virtual ~MD5();

    virtual void clear();

    virtual void finalize();

    virtual const unsigned char* rawDigest();

    inline static unsigned int rawLength()
        { return 16; }

    virtual unsigned int hashLength() const
        { return 16; }

protected:
    bool updateInternal(const void* buf, unsigned int len);

private:
    void init();
    unsigned char m_bin[16];
};

class YATE_API SHA1 : public Hasher
{
public:
    SHA1();

    SHA1(const SHA1& original);

    SHA1(const void* buf, unsigned int len);

    SHA1(const DataBlock& data);

    SHA1(const String& str);

    SHA1& operator=(const SHA1& original);

    virtual ~SHA1();

    virtual void clear();

    virtual void finalize();

    virtual const unsigned char* rawDigest();

    inline static unsigned int rawLength()
        { return 20; }

    virtual unsigned int hashLength() const
        { return 20; }

    static bool fips186prf(DataBlock& out, const DataBlock& seed, unsigned int len);

protected:
    bool updateInternal(const void* buf, unsigned int len);

private:
    void init();
    unsigned char m_bin[20];
};

class YATE_API SHA256 : public Hasher
{
public:
    SHA256();

    SHA256(const SHA256& original);

    SHA256(const void* buf, unsigned int len);

    SHA256(const DataBlock& data);

    SHA256(const String& str);

    SHA256& operator=(const SHA256& original);

    virtual ~SHA256();

    virtual void clear();

    virtual void finalize();

    virtual const unsigned char* rawDigest();

    inline static unsigned int rawLength()
        { return 32; }

    virtual unsigned int hashLength() const
        { return 32; }

protected:
    bool updateInternal(const void* buf, unsigned int len);

private:
    void init();
    unsigned char m_bin[32];
};

class YATE_API Base64 : public DataBlock
{
    YNOCOPY(Base64); // no automatic copies please
public:
    inline Base64()
        { }

    inline Base64(void* src, unsigned int len, bool copyData = true)
        : DataBlock(src,len,copyData)
        { }

    void encode(String& dest, unsigned int lineLen = 0, bool lineAtEnd = false);

    bool decode(DataBlock& dest, bool liberal = true);

    inline Base64& operator<<(const String& value)
        { append(value); return *this; }

    inline Base64& operator<<(const DataBlock& data)
        { append(data); return *this; }

    inline Base64& operator<<(const char* value)
        { return operator<<(String(value)); }
};

class NamedIterator;

class YATE_API NamedList : public String
{
    friend class NamedIterator;
public:
    explicit NamedList(const char* name);

    NamedList(const NamedList& original);

    NamedList(const char* name, const NamedList& original, const String& prefix);

    NamedList& operator=(const NamedList& value);

    virtual void* getObject(const String& name) const;

    inline unsigned int length() const
        { return m_params.length(); }

    inline unsigned int count() const
        { return m_params.count(); }

    inline void clearParams()
        { m_params.clear(); }

    NamedList& addParam(NamedString* param);

    NamedList& addParam(const char* name, const char* value, bool emptyOK = true);

    inline NamedList& setParam(NamedString* param)
    {
        if (param)
            m_params.setUnique(param);
        return *this;
    }

    NamedList& setParam(const String& name, const char* value);

    NamedList& clearParam(const String& name, char childSep = 0);

    NamedList& clearParam(NamedString* param, bool delParam = true);

    NamedList& copyParam(const NamedList& original, const String& name, char childSep = 0);

    NamedList& copyParams(const NamedList& original);

    NamedList& copyParams(const NamedList& original, ObjList* list, char childSep = 0);

    NamedList& copyParams(const NamedList& original, const String& list, char childSep = 0);

    NamedList& copySubParams(const NamedList& original, const String& prefix,
        bool skipPrefix = true, bool replace = false);

    bool hasSubParams(const char* prefix) const;

    int getIndex(const NamedString* param) const;

    int getIndex(const String& name) const;

    NamedString* getParam(const String& name) const;

    NamedString* getParam(unsigned int index) const;

    const String& operator[](const String& name) const;

    const char* getValue(const String& name, const char* defvalue = 0) const;

    int getIntValue(const String& name, int defvalue = 0, int minvalue = INT_MIN,
        int maxvalue = INT_MAX, bool clamp = true) const;

    int getIntValue(const String& name, const TokenDict* tokens, int defvalue = 0) const;

    int64_t getInt64Value(const String& name, int64_t defvalue = 0, int64_t minvalue = LLONG_MIN,
        int64_t maxvalue = LLONG_MAX, bool clamp = true) const;

    double getDoubleValue(const String& name, double defvalue = 0.0) const;

    bool getBoolValue(const String& name, bool defvalue = false) const;

    int replaceParams(String& str, bool sqlEsc = false, char extraEsc = 0) const;

    void dump(String& str, const char* separator, char quote = 0, bool force = false) const;

    static const NamedList& empty();

    inline ObjList* paramList()
        { return &m_params; }

    inline const ObjList* paramList() const
        { return &m_params; }

private:
    NamedList(); // no default constructor please
    ObjList m_params;
};

class YATE_API NamedIterator
{
public:
    inline NamedIterator(const NamedList& list)
        : m_list(&list), m_item(list.m_params.skipNull())
        { }

    inline NamedIterator(const NamedIterator& original)
        : m_list(original.m_list), m_item(original.m_item)
        { }

    inline NamedIterator& operator=(const NamedList& list)
        { m_list = &list; m_item = list.m_params.skipNull(); return *this; }

    inline NamedIterator& operator=(const NamedIterator& original)
        { m_list = original.m_list; m_item = original.m_item; return *this; }

    const NamedString* get();

    inline bool eof() const
        { return !m_item; }

    inline void reset()
        { m_item = m_list->m_params.skipNull(); }

private:
    NamedIterator(); // no default constructor please
    const NamedList* m_list;
    const ObjList* m_item;
};

class YATE_API URI : public String
{
public:
    URI();

    URI(const URI& uri);

    explicit URI(const String& uri);

    explicit URI(const char* uri);

    URI(const char* proto, const char* user, const char* host, int port = 0, const char* desc = 0);

    void parse() const;

    inline URI& operator=(const URI& value)
        { String::operator=(value); return *this; }

    inline URI& operator=(const String& value)
        { String::operator=(value); return *this; }

    inline URI& operator=(const char* value)
        { String::operator=(value); return *this; }

    inline const String& getDescription() const
        { parse(); return m_desc; }

    inline const String& getProtocol() const
        { parse(); return m_proto; }

    inline const String& getUser() const
        { parse(); return m_user; }

    inline const String& getHost() const
        { parse(); return m_host; }

    inline int getPort() const
        { parse(); return m_port; }

    inline const String& getExtra() const
        { parse(); return m_extra; }

protected:
    virtual void changed();
    mutable bool m_parsed;
    mutable String m_desc;
    mutable String m_proto;
    mutable String m_user;
    mutable String m_host;
    mutable String m_extra;
    mutable int m_port;
};

class MutexPrivate;
class SemaphorePrivate;
class ThreadPrivate;

class YATE_API Lockable
{
public:
    virtual ~Lockable();

    virtual bool lock(long maxwait = -1) = 0;

    virtual bool unlock() = 0;

    virtual bool locked() const = 0;

    virtual bool check(long maxwait = -1);

    virtual bool unlockAll();

    static void wait(unsigned long maxwait);

    static unsigned long wait();

    static void startUsingNow();

    static void enableSafety(bool safe = true);

    static bool safety();
};

class YATE_API Mutex : public Lockable
{
    friend class MutexPrivate;
public:
    explicit Mutex(bool recursive = false, const char* name = 0);

    Mutex(const Mutex& original);

    ~Mutex();

    Mutex& operator=(const Mutex& original);

    virtual bool lock(long maxwait = -1);

    virtual bool unlock();

    virtual bool locked() const;

    const char* owner() const;

    bool recursive() const;

    static int count();

    static int locks();

    static bool efficientTimedLock();

private:
    MutexPrivate* privDataCopy() const;
    MutexPrivate* m_private;
};

class YATE_API MutexPool
{
public:
    MutexPool(unsigned int len = 13, bool recursive = false, const char* name = 0);

    ~MutexPool();

    inline unsigned int index(void* ptr) const
        { return ((unsigned int)(unsigned long)ptr) % m_length; }

    inline Mutex* mutex(void* ptr) const
        { return m_data[index(ptr)]; }

    inline Mutex* mutex(unsigned int idx) const
        { return m_data[idx % m_length]; }

private:
    String* m_name;                      // Mutex names
    Mutex** m_data;                      // The array
    unsigned int m_length;               // Array length
};

class YATE_API Semaphore : public Lockable
{
    friend class SemaphorePrivate;
public:
    explicit Semaphore(unsigned int maxcount = 1, const char* name = 0,
        unsigned int initialCount = 1);

    Semaphore(const Semaphore& original);

    ~Semaphore();

    Semaphore& operator=(const Semaphore& original);

    virtual bool lock(long maxwait = -1);

    virtual bool unlock();

    virtual bool locked() const;

    static int count();

    static int locks();

    static bool efficientTimedLock();

private:
    SemaphorePrivate* privDataCopy() const;
    SemaphorePrivate* m_private;
};

class YATE_API Lock
{
    YNOCOPY(Lock); // no automatic copies please
public:
    inline Lock(Lockable& lck, long maxwait = -1)
        { m_lock = lck.lock(maxwait) ? &lck : 0; }

    inline Lock(Lockable* lck, long maxwait = -1)
        { m_lock = (lck && lck->lock(maxwait)) ? lck : 0; }

    inline ~Lock()
        { if (m_lock) m_lock->unlock(); }

    inline Lockable* locked() const
        { return m_lock; }

    inline void drop()
        { if (m_lock) m_lock->unlock(); m_lock = 0; }

    inline bool acquire(Lockable* lck, long maxwait = -1)
        { return (lck && (lck == m_lock)) ||
            (drop(),(lck && (m_lock = lck->lock(maxwait) ? lck : 0))); }

    inline bool acquire(Lockable& lck, long maxwait = -1)
        { return acquire(&lck,maxwait); }

private:
    Lockable* m_lock;

    inline void* operator new(size_t);

    inline void* operator new[](size_t);
};

class YATE_API Lock2
{
    YNOCOPY(Lock2); // no automatic copies please
public:
    inline Lock2(Mutex* mx1, Mutex* mx2, long maxwait = -1)
        : m_mx1(0), m_mx2(0)
        { lock(mx1,mx2,maxwait); }

    inline Lock2(Mutex& mx1, Mutex& mx2, long maxwait = -1)
        : m_mx1(0), m_mx2(0)
        { lock(&mx1,&mx2,maxwait); }

    inline ~Lock2()
        { drop(); }

    inline bool locked() const
        { return m_mx1 != 0; }

    bool lock(Mutex* mx1, Mutex* mx2, long maxwait = -1);

    inline bool lock(Mutex& mx1, Mutex& mx2, long maxwait = -1)
        { return lock(&mx1,&mx2,maxwait); }

    void drop();

private:
    Mutex* m_mx1;
    Mutex* m_mx2;

    inline void* operator new(size_t);

    inline void* operator new[](size_t);
};

class YATE_API Runnable
{
public:
    virtual void run() = 0;

    virtual ~Runnable();
};

class YATE_API Thread : public Runnable
{
    friend class ThreadPrivate;
    friend class MutexPrivate;
    friend class SemaphorePrivate;
    YNOCOPY(Thread); // no automatic copies please
public:
    enum Priority {
        Lowest,
        Low,
        Normal,
        High,
        Highest
    };

    virtual void cleanup();

    bool startup();

    bool error() const;

    bool running() const;

    inline int locks() const
        { return m_locks; }

    inline bool locked() const
        { return m_locking || m_locks; }

    const char* name() const;

    static const char* currentName();

    static void yield(bool exitCheck = false);

    static void idle(bool exitCheck = false);

    static void sleep(unsigned int sec, bool exitCheck = false);

    static void msleep(unsigned long msec, bool exitCheck = false);

    static void usleep(unsigned long usec, bool exitCheck = false);

    static unsigned long idleUsec();

    static unsigned long idleMsec();

    static void idleMsec(unsigned long msec);

    static Thread* current();

    static int count();

    static bool check(bool exitNow = true);

    static void exit();

    void cancel(bool hard = false);

    inline bool isCurrent() const
        { return current() == this; }

    NamedCounter* getObjCounter() const;

    NamedCounter* setObjCounter(NamedCounter* counter);

    static NamedCounter* getCurrentObjCounter(bool always = false);

    static NamedCounter* setCurrentObjCounter(NamedCounter* counter);

    static Priority priority(const char* name, Priority defvalue = Normal);

    static const char* priority(Priority prio);

    static void killall();

    static void preExec();

    static int lastError();

    static inline bool errorString(String& buffer)
        { return errorString(buffer,lastError()); }

    static bool errorString(String& buffer, int code);

protected:
    Thread(const char *name = 0, Priority prio = Normal);

    Thread(const char *name, const char* prio);

    virtual ~Thread();

private:
    ThreadPrivate* m_private;
    int m_locks;
    bool m_locking;
};

class YATE_API TempObjectCounter
{
    YNOCOPY(TempObjectCounter); // no automatic copies please
public:
    inline TempObjectCounter(NamedCounter* counter, bool enable = GenObject::getObjCounting())
        : m_saved(0), m_enabled(enable)
        { if (m_enabled) m_saved = Thread::setCurrentObjCounter(counter); }

    inline TempObjectCounter(const GenObject* obj, bool enable = GenObject::getObjCounting())
        : m_saved(0), m_enabled(enable && obj)
        { if (m_enabled) m_saved = Thread::setCurrentObjCounter(obj->getObjCounter()); }

    inline TempObjectCounter(const GenObject& obj, bool enable = GenObject::getObjCounting())
        : m_saved(0), m_enabled(enable)
        { if (m_enabled) m_saved = Thread::setCurrentObjCounter(obj.getObjCounter()); }

    inline ~TempObjectCounter()
        { if (m_enabled) Thread::setCurrentObjCounter(m_saved); }

private:
    NamedCounter* m_saved;
    bool m_enabled;
};

class Socket;

class YATE_API SocketAddr : public GenObject
{
    YCLASS(SocketAddr,GenObject)
public:
    enum Family {
        Unknown = AF_UNSPEC,
        IPv4 = AF_INET,
        AfMax = AF_MAX,
        AfUnsupported = AfMax,
#ifdef AF_INET6
        IPv6 = AF_INET6,
#else
        IPv6 = AfUnsupported + 1,
#endif
#ifdef HAS_AF_UNIX
        Unix = AF_UNIX,
#else
        Unix = AfUnsupported + 2,
#endif
    };

    inline SocketAddr()
        : m_address(0), m_length(0)
        { }

    inline SocketAddr(const SocketAddr& value)
        : GenObject(),
          m_address(0), m_length(0)
        { assign(value.address(),value.length()); }

    explicit SocketAddr(int family, const void* raw = 0);

    SocketAddr(const struct sockaddr* addr, socklen_t len = 0);

    virtual ~SocketAddr();

    inline SocketAddr& operator=(const SocketAddr& value)
        { assign(value.address(),value.length()); return *this; }

    bool operator==(const SocketAddr& other) const;

    inline bool operator!=(const SocketAddr& other) const
        { return !operator==(other); }

    void clear();

    bool assign(int family);

    void assign(const struct sockaddr* addr, socklen_t len = 0);

    bool assign(const DataBlock& addr);

    bool local(const SocketAddr& remote);

    inline bool valid() const
        { return m_length && m_address; }

    inline bool null() const
        { return !(m_length && m_address); }

    inline int family() const
        { return m_address ? m_address->sa_family : 0; }

    inline const char* familyName()
        { return lookupFamily(family()); }

    inline unsigned int scopeId() const
        { return scopeId(address()); }

    inline bool scopeId(unsigned int val)
        { return scopeId(address(),val); }

    inline const String& host() const
        { return m_host; }

    inline const String& addr() const {
            if (!m_addr)
                updateAddr();
            return m_addr;
        }

    virtual bool host(const String& name);

    int port() const;

    bool port(int newport);

    inline struct sockaddr* address() const
        { return m_address; }

    inline socklen_t length() const
        { return m_length; }

    inline bool isNullAddr() const
        { return isNullAddr(m_host,family()); }

    int copyAddr(DataBlock& addr) const;

    static bool supports(int family);

    static int family(const String& addr);

    static bool stringify(String& buf, struct sockaddr* addr);

    static inline int unStringify(uint8_t* buf, const String& host,
        int family = Unknown) {
            SocketAddr sa(family);
            return sa.host(host) ? copyAddr(buf,sa.address()) : Unknown;
        }

    static int copyAddr(uint8_t* buf, struct sockaddr* addr);

    static inline unsigned int scopeId(struct sockaddr* addr) {
#ifdef AF_INET6
            if (addr && addr->sa_family == AF_INET6)
                return ((struct sockaddr_in6*)addr)->sin6_scope_id;
#endif
            return 0;
        }

    static inline bool scopeId(struct sockaddr* addr, unsigned int val) {
#ifdef AF_INET6
            if (addr && addr->sa_family == AF_INET6) {
                ((struct sockaddr_in6*)addr)->sin6_scope_id = val;
                return true;
            }
#endif
            return false;
        }

    static String& appendAddr(String& buf, const String& addr, int family = Unknown);

    static inline String& appendTo(String& buf, const String& addr, int port,
        int family = Unknown) {
            appendAddr(buf,addr,family) << ":" << port;
            return buf;
        }

    static inline String appendTo(const String& addr, int port, int family = Unknown) {
            String buf;
            appendTo(buf,addr,port,family);
            return buf;
        }

    static bool isNullAddr(const String& addr, int family = Unknown);

    static void splitIface(const String& buf, String& addr, String* iface = 0);

    static void split(const String& buf, String& addr, int& port, bool portPresent = false);

    static inline const char* lookupFamily(int family)
        { return lookup(family,s_familyName); }

    static const String& ipv4NullAddr();

    static const String& ipv6NullAddr();

    static const TokenDict* dictFamilyName();

protected:
    virtual void stringify();

    virtual void updateAddr() const;

    struct sockaddr* m_address;
    socklen_t m_length;
    String m_host;
    mutable String m_addr;

private:
    static const TokenDict s_familyName[];
};

class YATE_API SocketFilter : public GenObject
{
    friend class Socket;
    YNOCOPY(SocketFilter); // no automatic copies please
public:
    SocketFilter();

    virtual ~SocketFilter();

    virtual void* getObject(const String& name) const;

    virtual void timerTick(const Time& when);

    virtual bool received(void* buffer, int length, int flags, const struct sockaddr* addr, socklen_t adrlen) = 0;

    inline Socket* socket() const
        { return m_socket; }

    bool valid() const;

private:
    Socket* m_socket;
};

class YATE_API Stream
{
public:
    enum SeekPos {
        SeekBegin,                       // Seek from start of stream
        SeekEnd,                         // Seek from stream end
        SeekCurrent                      // Seek from current position
    };

    virtual ~Stream();

    inline int error() const
        { return m_error; }

    virtual bool terminate() = 0;

    virtual bool canRetry() const;

    virtual bool inProgress() const;

    virtual bool valid() const = 0;

    virtual bool setBlocking(bool block = true);

    virtual int writeData(const void* buffer, int length) = 0;

    int writeData(const char* str);

    inline int writeData(const String& str)
        { return writeData(str.c_str(), str.length()); }

    inline int writeData(const DataBlock& buf)
        { return writeData(buf.data(), buf.length()); }

    virtual int readData(void* buffer, int length) = 0;

    virtual int64_t length();

    virtual int64_t seek(SeekPos pos, int64_t offset = 0);

    inline int64_t seek(int64_t offset)
        { return seek(SeekBegin,offset); }

    static bool allocPipe(Stream*& reader, Stream*& writer);

    static bool allocPair(Stream*& str1, Stream*& str2);

    static bool supportsPipes();

    static bool supportsPairs();

protected:
    inline Stream()
        : m_error(0)
        { }

    inline void clearError()
        { m_error = 0; }

    int m_error;
};

class YATE_API MemoryStream : public Stream
{
    YNOCOPY(MemoryStream); // no automatic copies please
public:
    inline MemoryStream()
        : m_offset(0)
        { }

    inline MemoryStream(const DataBlock& data)
        : m_data(data), m_offset(0)
        { }

    inline const DataBlock& data() const
        { return m_data; }

    virtual bool terminate()
        { return true; }
    virtual bool valid() const
        { return true; }

    virtual int writeData(const void* buffer, int len);

    virtual int readData(void* buffer, int len);

    virtual int64_t length()
        { return m_data.length(); }

    virtual int64_t seek(SeekPos pos, int64_t offset = 0);

protected:
    DataBlock m_data;

    int64_t m_offset;
};

class YATE_API File : public Stream
{
    YNOCOPY(File); // no automatic copies please
public:
    File();

    explicit File(HANDLE handle);

    virtual ~File();

    virtual bool openPath(const char* name, bool canWrite = false, bool canRead = true,
        bool create = false, bool append = false, bool binary = false,
        bool pubReadable = false, bool pubWritable = false);

    virtual bool terminate();

    void attach(HANDLE handle);

    HANDLE detach();

    inline HANDLE handle() const
        { return m_handle; }

    virtual bool canRetry() const;

    virtual bool valid() const;

    static HANDLE invalidHandle();

    virtual bool setBlocking(bool block = true);

    virtual int64_t length();

    virtual int64_t seek(SeekPos pos, int64_t offset = 0);

    virtual int writeData(const void* buffer, int length);

    virtual int readData(void* buffer, int length);

    bool getFileTime(unsigned int& secEpoch);

    virtual bool md5(String& buffer);

    static bool setFileTime(const char* name, unsigned int secEpoch, int* error = 0);

    static bool getFileTime(const char* name, unsigned int& secEpoch, int* error = 0);

    static bool exists(const char* name, int* error = 0);

    static bool rename(const char* oldFile, const char* newFile, int* error = 0);

    static bool remove(const char* name, int* error = 0);

    static bool md5(const char* name, String& buffer, int* error = 0);

    static bool mkDir(const char* path, int* error = 0, int mode = -1);

    static bool rmDir(const char* path, int* error = 0);

    static bool listDirectory(const char* path, ObjList* dirs, ObjList* files,
        int* error = 0);

    static bool createPipe(File& reader, File& writer);

protected:

    void copyError();

    HANDLE m_handle;
};

class YATE_API Socket : public Stream
{
    YNOCOPY(Socket); // no automatic copies please
public:
    enum TOS {
        Normal         = 0,
        LowDelay       = IPTOS_LOWDELAY,
        MaxThroughput  = IPTOS_THROUGHPUT,
        MaxReliability = IPTOS_RELIABILITY,
        MinCost        = IPTOS_MINCOST,
    };

    enum DSCP {
        DefaultPHB     = 0x00,
        // Class selectors
        CS0            = 0x00,
        CS1            = 0x20,
        CS2            = 0x40,
        CS3            = 0x60,
        CS4            = 0x80,
        CS5            = 0xa0,
        CS6            = 0xc0,
        CS7            = 0xe0,
        // Assured forwarding
        AF11           = 0x28,
        AF12           = 0x30,
        AF13           = 0x38,
        AF21           = 0x48,
        AF22           = 0x50,
        AF23           = 0x58,
        AF31           = 0x68,
        AF32           = 0x70,
        AF33           = 0x78,
        AF41           = 0x88,
        AF42           = 0x90,
        AF43           = 0x98,
        // Expedited forwarding
        ExpeditedFwd   = 0xb8,
        VoiceAdmit     = 0xb0,
    };

    Socket();

    explicit Socket(SOCKET handle);

    Socket(int domain, int type, int protocol = 0);

    virtual ~Socket();

    virtual bool create(int domain, int type, int protocol = 0);

    virtual bool terminate();

    void attach(SOCKET handle);

    SOCKET detach();

    inline SOCKET handle() const
        { return m_handle; }

    virtual bool canRetry() const;

    virtual bool inProgress() const;

    virtual bool valid() const;

    static SOCKET invalidHandle();

    static int socketError();

    static const TokenDict* tosValues();

    virtual bool setOption(int level, int name, const void* value = 0, socklen_t length = 0);

    inline bool setIpv6OnlyOption(bool on) {
#if defined(IPPROTO_IPV6) && defined(IPV6_V6ONLY)
            int value = on ? 1 : 0;
            return setOption(IPPROTO_IPV6,IPV6_V6ONLY,&value,sizeof(value));
#else
            return false;
#endif
        }

    virtual bool getOption(int level, int name, void* buffer, socklen_t* length);

    virtual bool setParams(const NamedList& params)
        { return false; }

    virtual bool getParams(const String& params, NamedList& result)
        { return false; }

    virtual bool setTOS(int tos);

    inline bool setTOS(const char* tos, int defTos = Normal)
        { return setTOS(lookup(tos,tosValues(),defTos)); }

    virtual int getTOS();

    virtual bool setBlocking(bool block = true);

    virtual bool setReuse(bool reuse = true, bool exclusive = false);

    virtual bool setLinger(int seconds = -1);

    virtual bool bind(struct sockaddr* addr, socklen_t addrlen);

    inline bool bind(const SocketAddr& addr)
        { return bind(addr.address(), addr.length()); }

    virtual bool listen(unsigned int backlog = 0);

    virtual Socket* accept(struct sockaddr* addr = 0, socklen_t* addrlen = 0);

    Socket* accept(SocketAddr& addr);

    SOCKET acceptHandle(struct sockaddr* addr = 0, socklen_t* addrlen = 0);

    bool updateError();

    static bool efficientSelect();

    static bool canSelect(SOCKET handle);

    virtual bool canSelect() const;

    virtual bool connect(struct sockaddr* addr, socklen_t addrlen);

    inline bool connect(const SocketAddr& addr)
        { return connect(addr.address(), addr.length()); }

    virtual bool connectAsync(struct sockaddr* addr, socklen_t addrlen, unsigned int toutUs,
        bool* timeout = 0);

    inline bool connectAsync(const SocketAddr& addr, unsigned int toutUs,
        bool* timeout = 0)
        { return connectAsync(addr.address(),addr.length(),toutUs,timeout); }

    virtual bool shutdown(bool stopReads, bool stopWrites);

    virtual bool getSockName(struct sockaddr* addr, socklen_t* addrlen);

    bool getSockName(SocketAddr& addr);

    virtual bool getPeerName(struct sockaddr* addr, socklen_t* addrlen);

    bool getPeerName(SocketAddr& addr);

    virtual int sendTo(const void* buffer, int length, const struct sockaddr* addr, socklen_t adrlen, int flags = 0);

    inline int sendTo(const void* buffer, int length, const SocketAddr& addr, int flags = 0)
        { return sendTo(buffer, length, addr.address(), addr.length(), flags); }

    virtual int send(const void* buffer, int length, int flags = 0);

    virtual int writeData(const void* buffer, int length);

    virtual int recvFrom(void* buffer, int length, struct sockaddr* addr = 0, socklen_t* adrlen = 0, int flags = 0);

    int recvFrom(void* buffer, int length, SocketAddr& addr, int flags = 0);

    virtual int recv(void* buffer, int length, int flags = 0);

    virtual int readData(void* buffer, int length);

    virtual bool select(bool* readok, bool* writeok, bool* except, struct timeval* timeout = 0);

    bool select(bool* readok, bool* writeok, bool* except, int64_t timeout);

    bool installFilter(SocketFilter* filter);

    void removeFilter(SocketFilter* filter, bool delobj = false);

    void clearFilters();

    virtual void timerTick(const Time& when);

    static bool createPair(Socket& sock1, Socket& sock2, int domain = AF_UNIX);

protected:

    void copyError();

    bool checkError(int retcode, bool strict = false);

    bool applyFilters(void* buffer, int length, int flags, const struct sockaddr* addr = 0, socklen_t adrlen = 0);

    SOCKET m_handle;
    ObjList m_filters;
};

class YATE_API SctpSocket : public Socket
{
    YNOCOPY(SctpSocket); // no automatic copies please
public:
     inline SctpSocket()
        { }

    inline explicit SctpSocket(SOCKET fd)
        : Socket(fd)
        { }

    virtual ~SctpSocket();

    virtual bool bindx(ObjList& addresses) = 0;

    virtual bool connectx(ObjList& addresses) = 0;

    virtual int sendTo(void* buffer, int length, int stream, SocketAddr& addr, int flags) = 0;

    virtual Socket* accept(SocketAddr& addr)
        { return 0; }

    virtual int sendMsg(const void* buf, int length, int stream, int& flags) = 0;

    virtual int recvMsg(void* buf, int length, SocketAddr& addr, int& stream, int& flags) = 0;

    virtual bool setStreams(int inbound, int outbound) = 0;

    virtual bool subscribeEvents() = 0;

    virtual bool getStreams(int& inbound, int& outbound) = 0;

    virtual bool setPayload(u_int32_t payload) = 0;
};

class YATE_API DnsRecord : public GenObject
{
    YCLASS(DnsRecord,GenObject)
    YNOCOPY(DnsRecord);
public:
    inline DnsRecord(int ttl, int order, int pref)
        : m_ttl(ttl), m_order(order), m_pref(pref)
        {}

    inline DnsRecord()
        : m_order(0), m_pref(0)
        {}

    inline int ttl() const
        { return m_ttl; }

    inline int order() const
        { return m_order; }

    inline int pref() const
        { return m_pref; }

    virtual void dump(String& buf, const char* sep = " ");

    static bool insert(ObjList& list, DnsRecord* rec, bool ascPref);

protected:
    int m_ttl;
    int m_order;
    int m_pref;
};

class YATE_API TxtRecord : public DnsRecord
{
    YCLASS(TxtRecord,DnsRecord)
    YNOCOPY(TxtRecord);
public:
    inline TxtRecord(int ttl, const char* text)
        : DnsRecord(ttl,-1,-1), m_text(text)
        {}

    inline const String& text() const
        { return m_text; }

    virtual void dump(String& buf, const char* sep = " ");

    static void copy(ObjList& dest, const ObjList& src);

protected:
    String m_text;

private:
    TxtRecord() {}                       // No default contructor
};

class YATE_API SrvRecord : public DnsRecord
{
    YCLASS(SrvRecord,DnsRecord)
    YNOCOPY(SrvRecord);
public:
    inline SrvRecord(int ttl, int prio, int weight, const char* addr, int port)
        : DnsRecord(ttl,prio,weight), m_address(addr), m_port(port)
        {}

    inline const String& address() const
        { return m_address; }

    inline int port() const
        { return m_port; }

    virtual void dump(String& buf, const char* sep = " ");

    static void copy(ObjList& dest, const ObjList& src);

protected:
    String m_address;
    int m_port;

private:
    SrvRecord() {}                       // No default contructor
};

class YATE_API NaptrRecord : public DnsRecord
{
    YCLASS(NaptrRecord,DnsRecord)
    YNOCOPY(NaptrRecord);
public:
    NaptrRecord(int ttl, int ord, int pref, const char* flags, const char* serv,
        const char* regexp, const char* next);

    bool replace(String& str) const;

    virtual void dump(String& buf, const char* sep = " ");

    inline const String& flags() const
        { return m_flags; }

    inline const String& serv() const
        { return m_service; }

    inline const Regexp& regexp() const
        { return m_regmatch; }

    inline const String& repTemplate() const
        { return m_template; }

    inline const String& nextName() const
        { return m_next; }

protected:
    String m_flags;
    String m_service;
    Regexp m_regmatch;
    String m_template;
    String m_next;

private:
    NaptrRecord() {}                     // No default contructor
};

class YATE_API Resolver
{
public:
    enum Type {
        Unknown,
        Srv,                             // SRV (Service Location)
        Naptr,                           // NAPTR (Naming Authority Pointer)
        A4,                              // A (Address)
        A6,                              // AAAA (IPv6 Address)
        Txt,                             // TXT (Text)
    };

    static bool available(Type type = Unknown);

    static bool init(int timeout = -1, int retries = -1);

    static int query(Type type, const char* dname, ObjList& result, String* error = 0);

    static int srvQuery(const char* dname, ObjList& result, String* error = 0);

    static int naptrQuery(const char* dname, ObjList& result, String* error = 0);

    static int a4Query(const char* dname, ObjList& result, String* error = 0);

    static int a6Query(const char* dname, ObjList& result, String* error = 0);

    static int txtQuery(const char* dname, ObjList& result, String* error = 0);

    static const TokenDict s_types[];
};

class YATE_API Cipher : public GenObject
{
public:
    enum Direction {
        Bidir,
        Encrypt,
        Decrypt,
    };

    inline static const TokenDict* directions()
        { return s_directions; }

    inline static Direction direction(const char* name, Direction defdir = Bidir)
        { return (Direction)TelEngine::lookup(name,s_directions,defdir); }

    virtual ~Cipher();

    virtual void* getObject(const String& name) const;

    virtual bool valid(Direction dir = Bidir) const;

    virtual unsigned int blockSize() const = 0;

    virtual unsigned int initVectorSize() const;

    unsigned int bufferSize(unsigned int len) const;

    bool bufferFull(unsigned int len) const;

    virtual bool setKey(const void* key, unsigned int len, Direction dir = Bidir) = 0;

    inline bool setKey(const DataBlock& key, Direction dir = Bidir)
        { return setKey(key.data(),key.length(),dir); }

    virtual bool initVector(const void* vect, unsigned int len, Direction dir = Bidir);

    inline bool initVector(const DataBlock& vect, Direction dir = Bidir)
        { return initVector(vect.data(),vect.length(),dir); }

    virtual bool encrypt(void* outData, unsigned int len, const void* inpData = 0) = 0;

    inline bool encrypt(DataBlock& data)
        { return encrypt(data.data(),data.length()); }

    virtual bool decrypt(void* outData, unsigned int len, const void* inpData = 0) = 0;

    inline bool decrypt(DataBlock& data)
        { return decrypt(data.data(),data.length()); }

private:
    static const TokenDict s_directions[];
};

class YATE_API Compressor : public String
{
    YCLASS(Compressor,String)
    YNOCOPY(Compressor); // no automatic copies please
public:
    inline Compressor(const char* format, const char* name = 0)
        : String(name), m_format(format)
        {}

    virtual ~Compressor()
        {}

    inline const String& format() const
        { return m_format; }

    virtual bool init(bool comp = true, bool decomp = true,
        const NamedList& params = NamedList::empty())
        { return true; }

    virtual void finalize(bool comp)
        {}

    virtual int compress(const void* buf, unsigned int len, DataBlock& dest);

    virtual int decompress(const void* buf, unsigned int len, DataBlock& dest);

    virtual int writeComp(const void* buf, unsigned int len, bool flush) = 0;

    inline int writeComp(const DataBlock& data, bool flush)
        { return writeComp(data.data(),data.length(),flush); }

    inline int writeComp(const String& data, bool flush)
        { return writeComp(data.c_str(),data.length(),flush); }

    virtual int readComp(DataBlock& buf, bool flush) = 0;

    virtual int writeDecomp(const void* buf, unsigned int len, bool flush) = 0;

    inline int writeDecomp(const DataBlock& data, bool flush)
        { return writeDecomp(data.data(),data.length(),flush); }

    inline int writeDecomp(const String& data, bool flush)
        { return writeDecomp(data.c_str(),data.length(),flush); }

    virtual int readDecomp(DataBlock& buf, bool flush) = 0;

protected:
    String m_format;
};

class YATE_API SysUsage
{
public:
    enum Type {
        WallTime,
        UserTime,
        KernelTime
    };

    static void init();

    static u_int64_t startTime();

    static u_int64_t usecRunTime(Type type = WallTime);

    static u_int64_t msecRunTime(Type type = WallTime);

    static u_int32_t secRunTime(Type type = WallTime);

    static double runTime(Type type = WallTime);

};

}; // namespace TelEngine

#endif /* __YATECLASS_H */

/* vi: set ts=8 sw=4 sts=4 noet: */