yateclass.h

00001 /*
00002  * yateclass.h
00003  * This file is part of the YATE Project http://YATE.null.ro
00004  *
00005  * Base classes and types, not related to the engine or telephony
00006  *
00007  * Yet Another Telephony Engine - a fully featured software PBX and IVR
00008  * Copyright (C) 2004-2006 Null Team
00009  *
00010  * This program is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2 of the License, or
00013  * (at your option) any later version.
00014  *
00015  * This program is distributed in the hope that it will be useful,
00016  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018  * GNU General Public License for more details.
00019  *
00020  * You should have received a copy of the GNU General Public License
00021  * along with this program; if not, write to the Free Software
00022  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
00023  */
00024 
00025 #ifndef __YATECLASS_H
00026 #define __YATECLASS_H
00027 
00028 #ifndef __cplusplus
00029 #error C++ is required
00030 #endif
00031 
00032 #include <sys/types.h>
00033 #include <stddef.h>
00034 #include <unistd.h>
00035 #include <errno.h>
00036 
00037 #ifndef _WORDSIZE
00038 #if defined(__arch64__) || defined(__x86_64__) \
00039     || defined(__amd64__) || defined(__ia64__) \
00040     || defined(__alpha__) || defined(__sparcv9)
00041 #define _WORDSIZE 64
00042 #else
00043 #define _WORDSIZE 32
00044 #endif
00045 #endif
00046 
00047 #ifndef _WINDOWS
00048 #if defined(WIN32) || defined(_WIN32)
00049 #define _WINDOWS
00050 #endif
00051 #endif
00052 
00053 #ifdef _WINDOWS
00054 
00055 #include <windows.h>
00056 #include <io.h>
00057 #include <direct.h>
00058 
00062 typedef signed __int8 int8_t;
00063 typedef unsigned __int8 u_int8_t;
00064 typedef unsigned __int8 uint8_t;
00065 typedef signed __int16 int16_t;
00066 typedef unsigned __int16 u_int16_t;
00067 typedef unsigned __int16 uint16_t;
00068 typedef signed __int32 int32_t;
00069 typedef unsigned __int32 u_int32_t;
00070 typedef unsigned __int32 uint32_t;
00071 typedef signed __int64 int64_t;
00072 typedef unsigned __int64 u_int64_t;
00073 typedef unsigned __int64 uint64_t;
00074 
00075 typedef int pid_t;
00076 typedef int socklen_t;
00077 typedef unsigned long in_addr_t;
00078 
00079 #ifndef strcasecmp
00080 #define strcasecmp _stricmp
00081 #endif
00082 
00083 #ifndef strncasecmp
00084 #define strncasecmp _strnicmp
00085 #endif
00086 
00087 #define vsnprintf _vsnprintf
00088 #define snprintf _snprintf
00089 #define strdup _strdup
00090 #define open _open
00091 #define dup2 _dup2
00092 #define read _read
00093 #define write _write
00094 #define close _close
00095 #define getpid _getpid
00096 #define chdir _chdir
00097 #define mkdir(p,m) _mkdir(p)
00098 #define unlink _unlink
00099 
00100 #define O_RDWR   _O_RDWR
00101 #define O_RDONLY _O_RDONLY
00102 #define O_WRONLY _O_WRONLY
00103 #define O_APPEND _O_APPEND
00104 #define O_BINARY _O_BINARY
00105 #define O_EXCL   _O_EXCL
00106 #define O_CREAT  _O_CREAT
00107 #define O_TRUNC  _O_TRUNC
00108 #define O_NOCTTY 0
00109 
00110 #define S_IRUSR _S_IREAD
00111 #define S_IWUSR _S_IWRITE
00112 #define S_IXUSR 0
00113 #define S_IRWXU (_S_IREAD|_S_IWRITE)
00114 
00115 #ifdef LIBYATE_EXPORTS
00116 #define YATE_API __declspec(dllexport)
00117 #else
00118 #ifndef LIBYATE_STATIC
00119 #define YATE_API __declspec(dllimport)
00120 #endif
00121 #endif
00122 
00123 #define FMT64 "%I64d"
00124 #define FMT64U "%I64u"
00125 
00126 #else /* _WINDOWS */
00127 
00128 #include <sys/time.h>
00129 #include <sys/socket.h>
00130 
00131 #if defined(__FreeBSD__)
00132 #include <netinet/in_systm.h>
00133 #endif
00134 
00135 #include <netinet/in.h>
00136 #include <netinet/ip.h>
00137 #include <netinet/tcp.h>
00138 #include <arpa/inet.h>
00139 #include <netdb.h>
00140 
00144 #ifndef SOCKET
00145 typedef int SOCKET;
00146 #endif
00147 #ifndef HANDLE
00148 typedef int HANDLE;
00149 #endif
00150 
00151 #ifndef O_BINARY
00152 #define O_BINARY 0
00153 #endif
00154 
00155 #if _WORDSIZE == 64
00156 #define FMT64 "%ld"
00157 #define FMT64U "%lu"
00158 #else
00159 #define FMT64 "%lld"
00160 #define FMT64U "%llu"
00161 #endif
00162 
00163 #endif /* ! _WINDOWS */
00164 
00165 #ifndef IPTOS_LOWDELAY
00166 #define IPTOS_LOWDELAY      0x10
00167 #define IPTOS_THROUGHPUT    0x08
00168 #define IPTOS_RELIABILITY   0x04
00169 #define IPTOS_MINCOST       0x02
00170 #endif
00171 
00172 #ifndef YATE_API
00173 #define YATE_API
00174 #endif
00175 
00176 #ifdef _WINDOWS
00177 #undef RAND_MAX
00178 #define RAND_MAX 2147483647
00179 extern "C" {
00180 YATE_API long int random();
00181 YATE_API void srandom(unsigned int seed);
00182 }
00183 #endif
00184 
00188 namespace TelEngine {
00189 
00190 #ifdef HAVE_GCC_FORMAT_CHECK
00191 #define FORMAT_CHECK(f) __attribute__((format(printf,(f),(f)+1)))
00192 #else
00193 #define FORMAT_CHECK(f)
00194 #endif
00195 
00200 YATE_API void abortOnBug();
00201 
00206 YATE_API bool abortOnBug(bool doAbort);
00207 
00213 enum DebugLevel {
00214     DebugFail = 0,
00215     DebugGoOn = 2,
00216     DebugStub = 4,
00217     DebugWarn = 5,
00218     DebugMild = 6,
00219     DebugCall = 7,
00220     DebugNote = 8,
00221     DebugInfo = 9,
00222     DebugAll = 10
00223 };
00224 
00229 YATE_API int debugLevel();
00230 
00236 YATE_API int debugLevel(int level);
00237 
00243 YATE_API bool debugAt(int level);
00244 
00251 YATE_API const char* debugColor(int level);
00252 
00258 class YATE_API DebugEnabler
00259 {
00260 public:
00266     inline DebugEnabler(int level = TelEngine::debugLevel(), bool enabled = true)
00267         : m_level(DebugFail), m_enabled(enabled), m_chain(0), m_name(0)
00268         { debugLevel(level); }
00269 
00270     inline ~DebugEnabler()
00271         { m_name = 0; m_chain = 0; }
00272 
00277     inline int debugLevel() const
00278         { return m_chain ? m_chain->debugLevel() : m_level; }
00279 
00285     int debugLevel(int level);
00286 
00291     inline bool debugEnabled() const
00292         { return m_chain ? m_chain->debugEnabled() : m_enabled; }
00293 
00298     inline void debugEnabled(bool enable)
00299         { m_enabled = enable; m_chain = 0; }
00300 
00305     inline const char* debugName() const
00306         { return m_name; }
00307 
00313     bool debugAt(int level) const;
00314 
00319     inline bool debugChained() const
00320         { return m_chain != 0; }
00321 
00326     inline void debugChain(const DebugEnabler* chain = 0)
00327         { m_chain = (chain != this) ? chain : 0; }
00328 
00333     void debugCopy(const DebugEnabler* original = 0);
00334 
00335 protected:
00340     inline void debugName(const char* name)
00341         { m_name = name; }
00342 
00343 private:
00344     int m_level;
00345     bool m_enabled;
00346     const DebugEnabler* m_chain;
00347     const char* m_name;
00348 };
00349 
00350 #if 0 /* for documentation generator */
00351 
00356 void DDebug(int level, const char* format, ...);
00357 
00363 void DDebug(const char* facility, int level, const char* format, ...);
00364 
00370 void DDebug(const DebugEnabler* local, int level, const char* format, ...);
00371 
00377 void XDebug(int level, const char* format, ...);
00378 
00384 void XDebug(const char* facility, int level, const char* format, ...);
00385 
00391 void XDebug(const DebugEnabler* local, int level, const char* format, ...);
00392 
00398 void NDebug(int level, const char* format, ...);
00399 
00405 void NDebug(const char* facility, int level, const char* format, ...);
00406 
00412 void NDebug(const DebugEnabler* local, int level, const char* format, ...);
00413 #endif
00414 
00415 #ifdef _DEBUG
00416 #undef DEBUG
00417 #define DEBUG
00418 #endif
00419 
00420 #ifdef XDEBUG
00421 #undef DEBUG
00422 #define DEBUG
00423 #endif
00424 
00425 #ifdef DEBUG
00426 #define DDebug Debug
00427 #else
00428 #ifdef _WINDOWS
00429 #define DDebug
00430 #else
00431 #define DDebug(arg...)
00432 #endif
00433 #endif
00434 
00435 #ifdef XDEBUG
00436 #define XDebug Debug
00437 #else
00438 #ifdef _WINDOWS
00439 #define XDebug
00440 #else
00441 #define XDebug(arg...)
00442 #endif
00443 #endif
00444 
00445 #ifndef NDEBUG
00446 #define NDebug Debug
00447 #else
00448 #ifdef _WINDOWS
00449 #define NDebug
00450 #else
00451 #define NDebug(arg...)
00452 #endif
00453 #endif
00454 
00460 YATE_API void Debug(int level, const char* format, ...) FORMAT_CHECK(2);
00461 
00468 YATE_API void Debug(const char* facility, int level, const char* format, ...) FORMAT_CHECK(3);
00469 
00476 YATE_API void Debug(const DebugEnabler* local, int level, const char* format, ...) FORMAT_CHECK(3);
00477 
00482 YATE_API void Output(const char* format, ...) FORMAT_CHECK(1);
00483 
00490 class YATE_API Debugger
00491 {
00492 public:
00496     enum Formatting {
00497         None = 0,
00498         Relative,  // from program start
00499         Absolute,  // from EPOCH (1-1-1970)
00500         Textual,   // absolute GMT in YYYYMMDDhhmmss.uuuuuu format
00501     };
00502 
00508     Debugger(const char* name, const char* format = 0, ...);
00509 
00516     Debugger(int level, const char* name, const char* format = 0, ...);
00517 
00521     ~Debugger();
00522 
00527     static void setOutput(void (*outFunc)(const char*,int) = 0);
00528 
00533     static void setIntOut(void (*outFunc)(const char*,int) = 0);
00534 
00540     static void enableOutput(bool enable = true, bool colorize = false);
00541 
00546     static void setFormatting(Formatting format);
00547 
00548 private:
00549     const char* m_name;
00550 };
00551 
00556 struct TokenDict {
00560     const char* token;
00561 
00565     int value;
00566 };
00567 
00568 class String;
00569 class Mutex;
00570 
00571 #if 0 /* for documentation generator */
00572 
00577 void YCLASS(class type,class base);
00578 
00584 void YCLASSIMP(class type,class base);
00585 
00592 class* YOBJECT(class type,GenObject* pntr);
00593 #endif
00594 
00595 #define YCLASS(type,base) \
00596 public: virtual void* getObject(const String& name) const \
00597 { return (name == #type) ? const_cast<type*>(this) : base::getObject(name); }
00598 
00599 #define YCLASSIMP(type,base) \
00600 void* type::getObject(const String& name) const \
00601 { return (name == #type) ? const_cast<type*>(this) : base::getObject(name); }
00602 
00603 #define YOBJECT(type,pntr) (static_cast<type*>((pntr) ? (pntr)->getObject(#type) : 0))
00604 
00608 class YATE_API GenObject
00609 {
00610 public:
00614     virtual ~GenObject() { }
00615 
00622     virtual bool alive() const;
00623 
00627     virtual void destruct();
00628 
00635     virtual const String& toString() const;
00636 
00642     virtual void* getObject(const String& name) const;
00643 };
00644 
00650 inline void destruct(GenObject* obj)
00651     { if (obj) obj->destruct(); }
00652 
00659 template <class Obj> void destruct(Obj*& obj)
00660     { if (obj) { obj->destruct(); obj = 0; } }
00661 
00666 class YATE_API RefObject : public GenObject
00667 {
00668 public:
00673     RefObject()
00674         : m_refcount(1) { }
00675 
00679     virtual ~RefObject();
00680 
00687     virtual bool alive() const;
00688 
00693     bool ref();
00694 
00703     bool deref();
00704 
00709     inline int refcount() const
00710         { return m_refcount; }
00711 
00716     virtual void destruct();
00717 
00722     static Mutex& refMutex();
00723 
00724 protected:
00730     virtual void zeroRefs();
00731 
00740     virtual bool zeroRefsTest();
00741 
00747     bool refInternal();
00748 
00754     bool resurrect();
00755 
00761     virtual void destroyed();
00762 
00763 private:
00764     int m_refcount;
00765 };
00766 
00772 class YATE_API RefPointerBase
00773 {
00774 protected:
00778     inline RefPointerBase()
00779         : m_pointer(0) { }
00780 
00787     void assign(RefObject* oldptr, RefObject* newptr, void* pointer);
00788 
00792     void* m_pointer;
00793 };
00794 
00798 template <class Obj = RefObject> class RefPointer : public RefPointerBase
00799 {
00800 protected:
00805     inline Obj* pointer() const
00806         { return static_cast<Obj*>(m_pointer); }
00807 
00812     inline void assign(Obj* object = 0)
00813         { RefPointerBase::assign(pointer(),object,object); }
00814 
00815 public:
00819     inline RefPointer()
00820         { }
00821 
00826     inline RefPointer(const RefPointer<Obj>& value)
00827         { assign(value); }
00828 
00833     inline RefPointer(Obj* object)
00834         { assign(object); }
00835 
00839     inline ~RefPointer()
00840         { assign(); }
00841 
00845     inline RefPointer<Obj>& operator=(const RefPointer<Obj>& value)
00846         { assign(value.pointer()); return *this; }
00847 
00851     inline RefPointer<Obj>& operator=(Obj* object)
00852         { assign(object); return *this; }
00853 
00858     inline operator Obj*() const
00859         { return pointer(); }
00860 
00864     inline Obj* operator->() const
00865         { return pointer(); }
00866 
00870     inline Obj& operator*() const
00871         { return *pointer(); }
00872 };
00873 
00877 template <class Obj = GenObject> class GenPointer : public GenObject
00878 {
00879 private:
00883     Obj* m_pointer;
00884 
00885 public:
00889     inline GenPointer()
00890         : m_pointer(0)
00891         { }
00892 
00897     inline GenPointer(const GenPointer<Obj>& value)
00898         : m_pointer(value)
00899         { }
00900 
00905     inline GenPointer(Obj* object)
00906         : m_pointer(object)
00907         { }
00908 
00912     inline GenPointer<Obj>& operator=(const GenPointer<Obj>& value)
00913         { m_pointer = value; return *this; }
00914 
00918     inline GenPointer<Obj>& operator=(Obj* object)
00919         { m_pointer = object; return *this; }
00920 
00925     inline operator Obj*() const
00926         { return m_pointer; }
00927 
00931     inline Obj* operator->() const
00932         { return m_pointer; }
00933 
00937     inline Obj& operator*() const
00938         { return *m_pointer; }
00939 };
00940 
00945 class YATE_API ObjList : public GenObject
00946 {
00947 public:
00951     ObjList();
00952 
00956     virtual ~ObjList();
00957 
00963     virtual void* getObject(const String& name) const;
00964 
00969     unsigned int length() const;
00970 
00975     unsigned int count() const;
00976 
00981     inline GenObject* get() const
00982         { return m_obj; }
00983 
00990     GenObject* set(const GenObject* obj, bool delold = true);
00991 
00996     inline ObjList* next() const
00997         { return m_next; }
00998 
01003     ObjList* last() const;
01004 
01009     ObjList* skipNull() const;
01010 
01015     ObjList* skipNext() const;
01016 
01022     ObjList* operator+(int index) const;
01023 
01029     GenObject* operator[](int index) const;
01030 
01036     GenObject* operator[](const String& str) const;
01037 
01043     ObjList* find(const GenObject* obj) const;
01044 
01050     ObjList* find(const String& str) const;
01051 
01058     ObjList* insert(const GenObject* obj, bool compact = true);
01059 
01066     ObjList* append(const GenObject* obj, bool compact = true);
01067 
01073     GenObject* remove(bool delobj = true);
01074 
01081     GenObject* remove(GenObject* obj, bool delobj = true);
01082 
01086     void clear();
01087 
01092     inline bool autoDelete()
01093         { return m_delete; }
01094 
01099     inline void setDelete(bool autodelete)
01100         { m_delete = autodelete; }
01101 
01102 private:
01103     ObjList* m_next;
01104     GenObject* m_obj;
01105     bool m_delete;
01106 };
01107 
01116 class YATE_API Array : public RefObject
01117 {
01118 public:
01124     Array(int columns = 0, int rows = 0);
01125 
01129     virtual ~Array();
01130 
01136     virtual void* getObject(const String& name) const;
01137 
01144     bool addRow(ObjList* row = 0, int index = -1);
01145     
01152     bool addColumn(ObjList* column = 0, int index = -1);
01153     
01159     bool delRow(int index);
01160 
01166     bool delColumn(int index);
01167  
01174     GenObject* get(int column, int row) const;
01175     
01183     bool set(GenObject* obj, int column, int row);
01184     
01189     inline int getRows() const
01190         { return m_rows; }
01191 
01196     inline int getColumns() const
01197         { return m_columns; }
01198 
01199 private:
01200     int m_rows;
01201     int m_columns;
01202     ObjList m_obj;
01203 };
01204 
01205 class Regexp;
01206 class StringMatchPrivate;
01207 
01215 class YATE_API String : public GenObject
01216 {
01217 public:
01221     String();
01222 
01228     String(const char* value, int len = -1);
01229 
01235     String(char value, unsigned int repeat = 1);
01236 
01241     String(int value);
01242 
01247     String(unsigned int value);
01248 
01253     String(bool value);
01254 
01259     String(const String& value);
01260 
01265     String(const String* value);
01266 
01270     virtual ~String();
01271 
01277     virtual void* getObject(const String& name) const;
01278 
01282     static const String& empty();
01283 
01289     inline static const char* boolText(bool value)
01290         { return value ? "true" : "false"; }
01291 
01296     inline const char* c_str() const
01297         { return m_string; }
01298 
01303     inline const char* safe() const
01304         { return m_string ? m_string : ""; }
01305 
01310     inline unsigned int length() const
01311         { return m_length; }
01312 
01317     inline bool null() const
01318         { return !m_string; }
01319 
01324     unsigned int hash() const;
01325 
01330     static unsigned int hash(const char* value);
01331 
01335     void clear();
01336 
01342     char at(int index) const;
01343 
01350     String substr(int offs, int len = -1) const;
01351 
01355     String& trimBlanks();
01356 
01361     virtual const String& toString() const;
01362 
01369     int toInteger(int defvalue = 0, int base = 0) const;
01370 
01378     int toInteger(const TokenDict* tokens, int defvalue = 0, int base = 0) const;
01379 
01385     double toDouble(double defvalue = 0.0) const;
01386 
01392     bool toBoolean(bool defvalue = false) const;
01393 
01398     bool isBoolean() const;
01399 
01404     String& toUpper();
01405 
01410     String& toLower();
01411 
01417     inline char operator[](int index) const
01418         { return at(index); }
01419 
01424     inline operator const char*() const
01425         { return m_string; };
01426 
01433     String& assign(const char* value, int len = -1);
01434 
01441     String& assign(char value, unsigned int repeat = 1);
01442 
01451     String& hexify(void* data, unsigned int len, char sep = 0, bool upCase = false);
01452 
01456     inline String& operator=(const String& value)
01457         { return operator=(value.c_str()); }
01458 
01463     inline String& operator=(const String* value)
01464         { return operator=(value ? value->c_str() : ""); }
01465 
01470     String& operator=(const char* value);
01471 
01475     String& operator=(char value);
01476 
01480     String& operator=(int value);
01481 
01485     String& operator=(unsigned int value);
01486 
01490     inline String& operator=(bool value)
01491         { return operator=(boolText(value)); }
01492 
01497     String& operator+=(const char* value);
01498 
01502     String& operator+=(char value);
01503 
01507     String& operator+=(int value);
01508 
01512     String& operator+=(unsigned int value);
01513 
01517     inline String& operator+=(bool value)
01518         { return operator+=(boolText(value)); }
01519 
01523     bool operator==(const char* value) const;
01524 
01528     bool operator!=(const char* value) const;
01529 
01533     bool operator==(const String& value) const;
01534 
01538     bool operator!=(const String& value) const;
01539 
01543     bool operator&=(const char* value) const;
01544 
01548     bool operator|=(const char* value) const;
01549 
01553     inline String& operator<<(const char* value)
01554         { return operator+=(value); }
01555 
01559     inline String& operator<<(char value)
01560         { return operator+=(value); }
01561 
01565     inline String& operator<<(int value)
01566         { return operator+=(value); }
01567 
01571     inline String& operator<<(unsigned int value)
01572         { return operator+=(value); }
01573 
01577     inline String& operator<<(bool value)
01578         { return operator+=(value); }
01579 
01584     String& operator>>(const char* skip);
01585 
01589     String& operator>>(char& store);
01590 
01594     String& operator>>(int& store);
01595 
01599     String& operator>>(unsigned int& store);
01600 
01604     String& operator>>(bool& store);
01605 
01612     String& append(const char* value, const char* separator = 0, bool force = false);
01613 
01620     String& append(const ObjList* list, const char* separator = 0, bool force = false);
01621 
01628     inline String& append(const ObjList& list, const char* separator = 0, bool force = false)
01629         { return append(&list,separator,force); }
01630 
01636     String& append(double value, unsigned int decimals = 3);
01637 
01644     int find(char what, unsigned int offs = 0) const;
01645 
01652     int find(const char* what, unsigned int offs = 0) const;
01653 
01659     int rfind(char what) const;
01660 
01668     bool startsWith(const char* what, bool wordBreak = false, bool caseInsensitive = false) const;
01669 
01677     bool endsWith(const char* what, bool wordBreak = false, bool caseInsensitive = false) const;
01678 
01690     bool startSkip(const char* what, bool wordBreak = true, bool caseInsensitive = false);
01691 
01697     virtual bool matches(const String& value) const
01698         { return operator==(value); }
01699 
01705     bool matches(Regexp& rexp);
01706 
01712     int matchOffset(int index = 0) const;
01713 
01719     int matchLength(int index = 0) const;
01720 
01726     inline String matchString(int index = 0) const
01727         { return substr(matchOffset(index),matchLength(index)); }
01728 
01734     String replaceMatches(const String& templ) const;
01735 
01740     int matchCount() const;
01741 
01748     ObjList* split(char separator, bool emptyOK = true) const;
01749 
01756     static String msgEscape(const char* str, char extraEsc = 0);
01757 
01763     inline String msgEscape(char extraEsc = 0) const
01764         { return msgEscape(c_str(),extraEsc); }
01765 
01773     static String msgUnescape(const char* str, int* errptr = 0, char extraEsc = 0);
01774 
01781     inline String msgUnescape(int* errptr = 0, char extraEsc = 0) const
01782         { return msgUnescape(c_str(),errptr,extraEsc); }
01783 
01790     static String sqlEscape(const char* str, char extraEsc = 0);
01791 
01797     inline String sqlEscape(char extraEsc = 0) const
01798         { return sqlEscape(c_str(),extraEsc); }
01799 
01806     static String uriEscape(const char* str, char extraEsc = 0);
01807 
01813     inline String uriEscape(char extraEsc = 0) const
01814         { return uriEscape(c_str(),extraEsc); }
01815 
01822     static String uriUnescape(const char* str, int* errptr = 0);
01823 
01829     inline String uriUnescape(int* errptr = 0) const
01830         { return uriUnescape(c_str(),errptr); }
01831 
01832 protected:
01836      virtual void changed();
01837 
01838 private:
01839     void clearMatches();
01840     char* m_string;
01841     unsigned int m_length;
01842     // I hope every C++ compiler now knows about mutable...
01843     mutable unsigned int m_hash;
01844     StringMatchPrivate* m_matches;
01845 };
01846 
01852 inline const char *c_safe(const char* str)
01853     { return str ? str : ""; }
01854 
01860 inline bool null(const char* str)
01861     { return !(str && *str); }
01862 
01866 YATE_API String operator+(const String& s1, const String& s2);
01867 
01871 YATE_API String operator+(const String& s1, const char* s2);
01872 
01876 YATE_API String operator+(const char* s1, const String& s2);
01877 
01882 inline const char *strcpy(String& dest, const char* src)
01883     { dest = src; return dest.c_str(); }
01884 
01889 inline const char *strcat(String& dest, const char* src)
01890     { dest += src; return dest.c_str(); }
01891 
01900 YATE_API int lookup(const char* str, const TokenDict* tokens, int defvalue = 0, int base = 0);
01901 
01908 YATE_API const char* lookup(int value, const TokenDict* tokens, const char* defvalue = 0);
01909 
01910 
01915 class YATE_API Regexp : public String
01916 {
01917     friend class String;
01918 public:
01922     Regexp();
01923 
01930     Regexp(const char* value, bool extended = false, bool insensitive = false);
01931 
01936     Regexp(const Regexp& value);
01937 
01941     virtual ~Regexp();
01942 
01946     inline Regexp& operator=(const char* value)
01947         { String::operator=(value); return *this; }
01948 
01953     bool compile();
01954 
01960     bool matches(const char* value) const;
01961 
01967     virtual bool matches(const String& value) const
01968         { return Regexp::matches(value.safe()); }
01969 
01975     void setFlags(bool extended, bool insensitive);
01976 
01981     bool isExtended() const;
01982 
01987     bool isCaseInsensitive() const;
01988 
01989 protected:
01993     virtual void changed();
01994 
01995 private:
01996     void cleanup();
01997     bool matches(const char *value, StringMatchPrivate *matchlist);
01998     void* m_regexp;
01999     int m_flags;
02000 };
02001 
02006 class YATE_API NamedString : public String
02007 {
02008 public:
02014     NamedString(const char* name, const char* value = 0);
02015 
02020     inline const String& name() const
02021         { return m_name; }
02022 
02027     virtual const String& toString() const;
02028 
02032     inline NamedString& operator=(const char* value)
02033         { String::operator=(value); return *this; }
02034 
02035 private:
02036     NamedString(); // no default constructor please
02037     String m_name;
02038 };
02039 
02047 class YATE_API HashList : public GenObject
02048 {
02049 public:
02054     HashList(unsigned int size = 17);
02055 
02059     virtual ~HashList();
02060 
02066     virtual void* getObject(const String& name) const;
02067 
02072     inline unsigned int length() const
02073         { return m_size; }
02074 
02079     unsigned int count() const;
02080 
02087     inline ObjList* getList(unsigned int index) const
02088         { return (index < m_size) ? m_lists[index] : 0; }
02089 
02095     inline ObjList* getHashList(unsigned int hash) const
02096         { return getList(hash % m_size); }
02097 
02103     inline ObjList* getHashList(const String& str) const
02104         { return getHashList(str.hash()); }
02105 
02111     GenObject* operator[](const String& str) const;
02112 
02118     ObjList* find(const GenObject* obj) const;
02119 
02125     ObjList* find(const String& str) const;
02126 
02132     ObjList* append(const GenObject* obj);
02133 
02140     GenObject* remove(GenObject* obj, bool delobj = true);
02141 
02145     void clear();
02146 
02153     bool resync(GenObject* obj);
02154 
02160     bool resync();
02161 
02162 private:
02163     unsigned int m_size;
02164     ObjList** m_lists;
02165 };
02166 
02173 class YATE_API ListIterator
02174 {
02175 public:
02181     ListIterator(ObjList& list);
02182 
02188     ListIterator(HashList& list);
02189 
02193     ~ListIterator();
02194 
02199     inline unsigned int length() const
02200         { return m_length; }
02201 
02208     GenObject* get(unsigned int index) const;
02209 
02222     GenObject* get();
02223 
02228     inline bool eof() const
02229         { return m_current >= m_length; }
02230 
02234     inline void reset()
02235         { m_current = 0; }
02236 
02237 private:
02238     ObjList* m_objList;
02239     HashList* m_hashList;
02240     GenObject** m_objects;
02241     unsigned int m_length;
02242     unsigned int m_current;
02243 };
02244 
02249 class YATE_API Time
02250 {
02251 public:
02255     inline Time()
02256         : m_time(now())
02257         { }
02258 
02263     inline Time(u_int64_t usec)
02264         : m_time(usec)
02265         { }
02266 
02271     inline Time(const struct timeval* tv)
02272         : m_time(fromTimeval(tv))
02273         { }
02274 
02279     inline Time(const struct timeval& tv)
02280         : m_time(fromTimeval(tv))
02281         { }
02282 
02287     inline ~Time()
02288         { }
02289 
02294     inline u_int32_t sec() const
02295         { return (u_int32_t)((m_time+500000) / 1000000); }
02296 
02301     inline u_int64_t msec() const
02302         { return (m_time+500) / 1000; }
02303 
02308     inline u_int64_t usec() const
02309         { return m_time; }
02310 
02314     inline operator u_int64_t() const
02315         { return m_time; }
02316 
02320     inline Time& operator=(u_int64_t usec)
02321         { m_time = usec; return *this; }
02322 
02326     inline Time& operator+=(int64_t delta)
02327         { m_time += delta; return *this; }
02328 
02332     inline Time& operator-=(int64_t delta)
02333         { m_time -= delta; return *this; }
02334 
02339     inline void toTimeval(struct timeval* tv) const
02340         { toTimeval(tv, m_time); }
02341 
02347     static void toTimeval(struct timeval* tv, u_int64_t usec);
02348 
02354     static u_int64_t fromTimeval(const struct timeval* tv);
02355 
02361     inline static u_int64_t fromTimeval(const struct timeval& tv)
02362         { return fromTimeval(&tv); }
02363 
02368     static u_int64_t now();
02369 
02374     static u_int64_t msecNow();
02375 
02380     static u_int32_t secNow();
02381 
02382 private:
02383     u_int64_t m_time;
02384 };
02385 
02390 class YATE_API DataBlock : public GenObject
02391 {
02392 public:
02393 
02397     DataBlock();
02398 
02402     DataBlock(const DataBlock& value);
02403 
02410     DataBlock(void* value, unsigned int len, bool copyData = true);
02411 
02415     virtual ~DataBlock();
02416 
02422     virtual void* getObject(const String& name) const;
02423 
02427     static const DataBlock& empty();
02428 
02433     inline void* data() const
02434         { return m_data; }
02435 
02440     inline bool null() const
02441         { return !m_data; }
02442 
02447     inline unsigned int length() const
02448         { return m_length; }
02449 
02454     void clear(bool deleteData = true);
02455 
02462     DataBlock& assign(void* value, unsigned int len, bool copyData = true);
02463 
02468     void append(const DataBlock& value);
02469 
02474     void append(const String& value);
02475 
02480     void insert(const DataBlock& value);
02481 
02486     void truncate(unsigned int len);
02487 
02492     void cut(int len);
02493 
02497     DataBlock& operator=(const DataBlock& value);
02498 
02502     inline DataBlock& operator+=(const DataBlock& value)
02503         { append(value); return *this; }
02504 
02508     inline DataBlock& operator+=(const String& value)
02509         { append(value); return *this; }
02510 
02519     bool convert(const DataBlock& src, const String& sFormat,
02520         const String& dFormat, unsigned maxlen = 0);
02521 
02522 private:
02523     void* m_data;
02524     unsigned int m_length;
02525 };
02526 
02531 class YATE_API MD5
02532 {
02533 public:
02537     MD5();
02538 
02543     MD5(const MD5& original);
02544 
02550     MD5(const void* buf, unsigned int len);
02551 
02556     MD5(const DataBlock& data);
02557 
02562     MD5(const String& str);
02563 
02567     ~MD5();
02568 
02572     MD5& operator=(const MD5& original);
02573 
02577     void clear();
02578 
02583     void finalize();
02584 
02591     bool update(const void* buf, unsigned int len);
02592 
02598     inline bool update(const DataBlock& data)
02599         { return update(data.data(), data.length()); }
02600 
02606     inline bool update(const String& str)
02607         { return update(str.c_str(), str.length()); }
02608 
02612     inline MD5& operator<<(const String& value)
02613         { update(value); return *this; }
02614 
02618     inline MD5& operator<<(const DataBlock& data)
02619         { update(data); return *this; }
02620 
02624     MD5& operator<<(const char* value);
02625 
02631     const unsigned char* rawDigest();
02632 
02637     inline static unsigned int rawLength()
02638         { return 16; }
02639 
02645     const String& hexDigest();
02646 
02647 private:
02648     void init();
02649     void* m_private;
02650     String m_hex;
02651     unsigned char m_bin[16];
02652 };
02653 
02658 class YATE_API SHA1
02659 {
02660 public:
02664     SHA1();
02665 
02670     SHA1(const SHA1& original);
02671 
02677     SHA1(const void* buf, unsigned int len);
02678 
02683     SHA1(const DataBlock& data);
02684 
02689     SHA1(const String& str);
02690 
02694     ~SHA1();
02695 
02699     SHA1& operator=(const SHA1& original);
02700 
02704     void clear();
02705 
02710     void finalize();
02711 
02718     bool update(const void* buf, unsigned int len);
02719 
02725     inline bool update(const DataBlock& data)
02726         { return update(data.data(), data.length()); }
02727 
02733     inline bool update(const String& str)
02734         { return update(str.c_str(), str.length()); }
02735 
02739     inline SHA1& operator<<(const String& value)
02740         { update(value); return *this; }
02741 
02745     inline SHA1& operator<<(const DataBlock& data)
02746         { update(data); return *this; }
02747 
02751     SHA1& operator<<(const char* value);
02752 
02758     const unsigned char* rawDigest();
02759 
02764     inline static unsigned int rawLength()
02765         { return 20; }
02766 
02772     const String& hexDigest();
02773 
02774 private:
02775     void init();
02776     void* m_private;
02777     String m_hex;
02778     unsigned char m_bin[20];
02779 };
02780 
02785 class YATE_API NamedList : public String
02786 {
02787 public:
02792     NamedList(const char* name);
02793 
02798     NamedList(const NamedList& original);
02799 
02805     virtual void* getObject(const String& name) const;
02806 
02811     inline unsigned int length() const
02812         { return m_params.length(); }
02813 
02818     inline unsigned int count() const
02819         { return m_params.count(); }
02820 
02825     NamedList& addParam(NamedString* param);
02826 
02832     NamedList& addParam(const char* name, const char* value);
02833 
02838     NamedList& setParam(NamedString* param);
02839 
02845     NamedList& setParam(const char* name, const char* value);
02846 
02852     NamedList& clearParam(const String& name, char childSep = 0);
02853 
02860     NamedList& copyParam(const NamedList& original, const String& name, char childSep = 0);
02861 
02868     NamedList& copyParams(const NamedList& original, ObjList* list, char childSep = 0);
02869 
02876     NamedList& copyParams(const NamedList& original, const String& list, char childSep = 0);
02877 
02883     int getIndex(const NamedString* param) const;
02884 
02890     int getIndex(const String& name) const;
02891 
02897     NamedString* getParam(const String& name) const;
02898 
02904     NamedString* getParam(unsigned int index) const;
02905 
02912     const char* getValue(const String& name, const char* defvalue = 0) const;
02913 
02920     int getIntValue(const String& name, int defvalue = 0) const;
02921 
02929     int getIntValue(const String& name, const TokenDict* tokens, int defvalue = 0) const;
02930 
02937     double getDoubleValue(const String& name, double defvalue = 0.0) const;
02938 
02945     bool getBoolValue(const String& name, bool defvalue = false) const;
02946 
02954     int replaceParams(String& str, bool sqlEsc = false, char extraEsc = 0) const;
02955 
02956 private:
02957     NamedList(); // no default constructor please
02958     NamedList& operator=(const NamedList& value); // no assignment please
02959     ObjList m_params;
02960 };
02961 
02967 class YATE_API URI : public String
02968 {
02969 public:
02973     URI();
02974 
02979     URI(const URI& uri);
02980 
02985     URI(const String& uri);
02986 
02991     URI(const char* uri);
02992 
03001     URI(const char* proto, const char* user, const char* host, int port = 0, const char* desc = 0);
03002 
03006     void parse() const;
03007 
03012     inline URI& operator=(const URI& value)
03013         { String::operator=(value); return *this; }
03014 
03019     inline URI& operator=(const String& value)
03020         { String::operator=(value); return *this; }
03021 
03026     inline URI& operator=(const char* value)
03027         { String::operator=(value); return *this; }
03028 
03033     inline const String& getDescription() const
03034         { parse(); return m_desc; }
03035 
03040     inline const String& getProtocol() const
03041         { parse(); return m_proto; }
03042 
03047     inline const String& getUser() const
03048         { parse(); return m_user; }
03049 
03054     inline const String& getHost() const
03055         { parse(); return m_host; }
03056 
03061     inline int getPort() const
03062         { parse(); return m_port; }
03063 protected:
03069     virtual void changed();
03070     mutable bool m_parsed;
03071     mutable String m_desc;
03072     mutable String m_proto;
03073     mutable String m_user;
03074     mutable String m_host;
03075     mutable int m_port;
03076 };
03077 
03078 class MutexPrivate;
03079 class ThreadPrivate;
03080 
03085 class YATE_API Mutex
03086 {
03087     friend class MutexPrivate;
03088 public:
03092     Mutex();
03093 
03099     Mutex(bool recursive);
03100 
03105     Mutex(const Mutex& original);
03106 
03110     ~Mutex();
03111 
03116     Mutex& operator=(const Mutex& original);
03117 
03123     bool lock(long maxwait = -1);
03124 
03128     void unlock();
03129 
03135     bool locked() const;
03136 
03142     bool check(long maxwait = -1);
03143 
03148     bool recursive() const;
03149 
03154     static int count();
03155 
03160     static int locks();
03161 
03167     static void wait(unsigned long maxwait);
03168 
03169 private:
03170     MutexPrivate* privDataCopy() const;
03171     MutexPrivate* m_private;
03172 };
03173 
03179 class YATE_API Lock
03180 {
03181 public:
03187     inline Lock(Mutex& mutex, long maxwait = -1)
03188         { m_mutex = mutex.lock(maxwait) ? &mutex : 0; }
03189 
03195     inline Lock(Mutex* mutex, long maxwait = -1)
03196         { m_mutex = (mutex && mutex->lock(maxwait)) ? mutex : 0; }
03197 
03201     inline ~Lock()
03202         { if (m_mutex) m_mutex->unlock(); }
03203 
03208     inline Mutex* mutex() const
03209         { return m_mutex; }
03210 
03214     inline void drop()
03215         { if (m_mutex) m_mutex->unlock(); m_mutex = 0; }
03216 
03217 private:
03218     Mutex* m_mutex;
03219 
03221     inline void* operator new(size_t);
03222 
03224     inline void* operator new[](size_t);
03225 
03227     inline Lock(const Lock&);
03228 };
03229 
03236 class YATE_API Lock2
03237 {
03238 public:
03245     inline Lock2(Mutex* mx1, Mutex* mx2, long maxwait = -1)
03246         : m_mx1(0), m_mx2(0)
03247         { lock(mx1,mx2,maxwait); }
03248 
03255     inline Lock2(Mutex& mx1, Mutex& mx2, long maxwait = -1)
03256         : m_mx1(0), m_mx2(0)
03257         { lock(&mx1,&mx2); }
03258 
03262     inline ~Lock2()
03263         { drop(); }
03264 
03269     inline bool locked() const
03270         { return m_mx1 != 0; }
03271 
03279     bool lock(Mutex* mx1, Mutex* mx2, long maxwait = -1);
03280 
03288     inline bool lock(Mutex& mx1, Mutex& mx2, long maxwait = -1)
03289         { return lock(&mx1,&mx2); }
03290 
03294     void drop();
03295 
03296 private:
03297     Mutex* m_mx1;
03298     Mutex* m_mx2;
03299 
03301     inline void* operator new(size_t);
03302 
03304     inline void* operator new[](size_t);
03305 
03307     inline Lock2(const Lock2&);
03308 };
03309 
03315 class YATE_API Runnable
03316 {
03317 public:
03322     virtual void run() = 0;
03323 
03327     virtual ~Runnable();
03328 };
03329 
03336 class YATE_API Thread : public Runnable
03337 {
03338     friend class ThreadPrivate;
03339     friend class MutexPrivate;
03340 public:
03344     enum Priority {
03345         Lowest,
03346         Low,
03347         Normal,
03348         High,
03349         Highest
03350     };
03351 
03355     virtual void cleanup();
03356 
03361     bool startup();
03362 
03367     bool error() const;
03368 
03373     bool running() const;
03374 
03379     inline int locks() const
03380         { return m_locks; }
03381 
03386     inline bool locked() const
03387         { return m_locking || m_locks; }
03388 
03393     const char* name() const;
03394 
03399     static const char* currentName();
03400 
03406     static void yield(bool exitCheck = false);
03407 
03413     static void sleep(unsigned int sec, bool exitCheck = false);
03414 
03420     static void msleep(unsigned long msec, bool exitCheck = false);
03421 
03428     static void usleep(unsigned long usec, bool exitCheck = false);
03429 
03435     static Thread* current();
03436 
03441     static int count();
03442 
03448     static bool check(bool exitNow = true);
03449 
03453     static void exit();
03454 
03459     void cancel(bool hard = false);
03460 
03465     inline bool isCurrent() const
03466         { return current() == this; }
03467 
03468 
03475     static Priority priority(const char* name, Priority defvalue = Normal);
03476 
03482     static const char* priority(Priority prio);
03483 
03488     static void killall();
03489 
03494     static void preExec();
03495 
03496 protected:
03502     Thread(const char *name = 0, Priority prio = Normal);
03503 
03509     Thread(const char *name, const char* prio);
03510 
03514     virtual ~Thread();
03515 
03516 private:
03517     ThreadPrivate* m_private;
03518     int m_locks;
03519     bool m_locking;
03520 };
03521 
03522 class Socket;
03523 
03528 class YATE_API SocketAddr : public GenObject
03529 {
03530 public:
03534     inline SocketAddr()
03535         : m_address(0), m_length(0)
03536         { }
03537 
03542     inline SocketAddr(const SocketAddr& value)
03543         : m_address(0), m_length(0)
03544         { assign(value.address(),value.length()); }
03545 
03550     SocketAddr(int family);
03551 
03557     SocketAddr(const struct sockaddr* addr, socklen_t len = 0);
03558 
03562     virtual ~SocketAddr();
03563 
03568     inline SocketAddr& operator=(const SocketAddr& value)
03569         { assign(value.address(),value.length()); return *this; }
03570 
03576     bool operator==(const SocketAddr& other) const;
03577 
03583     inline bool operator!=(const SocketAddr& other) const
03584         { return !operator==(other); }
03585 
03589     void clear();
03590 
03596     bool assign(int family);
03597 
03603     void assign(const struct sockaddr* addr, socklen_t len = 0);
03604 
03610     bool local(const SocketAddr& remote);
03611 
03616     inline bool valid() const
03617         { return m_length && m_address; }
03618 
03623     inline bool null() const
03624         { return !(m_length && m_address); }
03625 
03630     inline int family() const
03631         { return m_address ? m_address->sa_family : 0; }
03632 
03637     inline const String& host() const
03638         { return m_host; }
03639 
03644     virtual bool host(const String& name);
03645 
03650     int port() const;
03651 
03657     bool port(int newport);
03658 
03663     inline struct sockaddr* address() const
03664         { return m_address; }
03665 
03670     inline socklen_t length() const
03671         { return m_length; }
03672 
03678     static bool supports(int family);
03679 
03680 protected:
03684     virtual void stringify();
03685 
03686     struct sockaddr* m_address;
03687     socklen_t m_length;
03688     String m_host;
03689 };
03690 
03695 class YATE_API SocketFilter : public GenObject
03696 {
03697     friend class Socket;
03698 public:
03702     SocketFilter();
03703 
03707     virtual ~SocketFilter();
03708 
03714     virtual void* getObject(const String& name) const;
03715 
03720     virtual void timerTick(const Time& when);
03721 
03731     virtual bool received(void* buffer, int length, int flags, const struct sockaddr* addr, socklen_t adrlen) = 0;
03732 
03737     inline Socket* socket() const
03738         { return m_socket; }
03739 
03744     bool valid() const;
03745 
03746 private:
03747     Socket* m_socket;
03748 };
03749 
03754 class YATE_API Stream
03755 {
03756 public:
03760     virtual ~Stream();
03761 
03766     inline int error() const
03767         { return m_error; }
03768 
03773     virtual bool terminate() = 0;
03774 
03779     virtual bool canRetry() const;
03780 
03785     virtual bool valid() const = 0;
03786 
03792     virtual bool setBlocking(bool block = true);
03793 
03800     virtual int writeData(const void* buffer, int length) = 0;
03801 
03807     int writeData(const char* str);
03808 
03814     inline int writeData(const String& str)
03815         { return writeData(str.c_str(), str.length()); }
03816 
03822     inline int writeData(const DataBlock& buf)
03823         { return writeData(buf.data(), buf.length()); }
03824 
03831     virtual int readData(void* buffer, int length) = 0;
03832 
03839     static bool allocPipe(Stream*& reader, Stream*& writer);
03840 
03847     static bool allocPair(Stream*& str1, Stream*& str2);
03848 
03853     static bool supportsPipes();
03854 
03859     static bool supportsPairs();
03860 
03861 protected:
03865     inline Stream()
03866         : m_error(0)
03867         { }
03868 
03872     inline void clearError()
03873         { m_error = 0; }
03874 
03875     int m_error;
03876 };
03877 
03882 class YATE_API File : public Stream
03883 {
03884 public:
03888     File();
03889 
03894     File(HANDLE handle);
03895 
03899     virtual ~File();
03900 
03911     virtual bool openPath(const char* name, bool canWrite = false, bool canRead = true,
03912         bool create = false, bool append = false, bool binary = false);
03913 
03918     virtual bool terminate();
03919 
03924     void attach(HANDLE handle);
03925 
03930     HANDLE detach();
03931 
03936     inline HANDLE handle() const
03937         { return m_handle; }
03938 
03943     virtual bool canRetry() const;
03944 
03949     virtual bool valid() const;
03950 
03955     static HANDLE invalidHandle();
03956 
03962     virtual bool setBlocking(bool block = true);
03963 
03968     virtual unsigned int length();
03969 
03976     virtual int writeData(const void* buffer, int length);
03977 
03984     virtual int readData(void* buffer, int length);
03985 
03991     static bool remove(const char* name);
03992 
03999     static bool createPipe(File& reader, File& writer);
04000 
04001 protected:
04002 
04006     void copyError();
04007 
04008     HANDLE m_handle;
04009 };
04010 
04015 class YATE_API Socket : public Stream
04016 {
04017 public:
04021     enum TOS {
04022         LowDelay       = IPTOS_LOWDELAY,
04023         MaxThroughput  = IPTOS_THROUGHPUT,
04024         MaxReliability = IPTOS_RELIABILITY,
04025         MinCost        = IPTOS_MINCOST,
04026     };
04027 
04031     Socket();
04032 
04037     Socket(SOCKET handle);
04038 
04045     Socket(int domain, int type, int protocol = 0);
04046 
04050     virtual ~Socket();
04051 
04059     bool create(int domain, int type, int protocol = 0);
04060 
04065     virtual bool terminate();
04066 
04071     void attach(SOCKET handle);
04072 
04077     SOCKET detach();
04078 
04083     inline SOCKET handle() const
04084         { return m_handle; }
04085 
04090     virtual bool canRetry() const;
04091 
04096     virtual bool valid() const;
04097 
04102     static SOCKET invalidHandle();
04103 
04108     static int socketError();
04109 
04118     bool setOption(int level, int name, const void* value = 0, socklen_t length = 0);
04119 
04128     bool getOption(int level, int name, void* buffer, socklen_t* length);
04129 
04135     bool setTOS(int tos);
04136     
04142     virtual bool setBlocking(bool block = true);
04143 
04151     bool setReuse(bool reuse = true, bool exclusive = false);
04152 
04159     bool setLinger(int seconds = -1);
04160 
04167     bool bind(struct sockaddr* addr, socklen_t addrlen);
04168 
04174     inline bool bind(const SocketAddr& addr)
04175         { return bind(addr.address(), addr.length()); }
04176 
04182     bool listen(unsigned int backlog = 0);
04183 
04190     Socket* accept(struct sockaddr* addr = 0, socklen_t* addrlen = 0);
04191 
04197     Socket* accept(SocketAddr& addr);
04198 
04205     SOCKET acceptHandle(struct sockaddr* addr = 0, socklen_t* addrlen = 0);
04206 
04212     Socket* peelOff(unsigned int assoc);
04213 
04219     SOCKET peelOffHandle(unsigned int assoc);
04220 
04227     bool connect(struct sockaddr* addr, socklen_t addrlen);
04228 
04234     inline bool connect(const SocketAddr& addr)
04235         { return connect(addr.address(), addr.length()); }
04236 
04243     bool shutdown(bool stopReads, bool stopWrites);
04244 
04251     bool getSockName(struct sockaddr* addr, socklen_t* addrlen);
04252 
04258     bool getSockName(SocketAddr& addr);
04259 
04266     bool getPeerName(struct sockaddr* addr, socklen_t* addrlen);
04267 
04273     bool getPeerName(SocketAddr& addr);
04274 
04284     int sendTo(const void* buffer, int length, const struct sockaddr* addr, socklen_t adrlen, int flags = 0);
04285 
04294     inline int sendTo(const void* buffer, int length, const SocketAddr& addr, int flags = 0)
04295         { return sendTo(buffer, length, addr.address(), addr.length(), flags); }
04296 
04304     int send(const void* buffer, int length, int flags = 0);
04305 
04312     virtual int writeData(const void* buffer, int length);
04313 
04323     int recvFrom(void* buffer, int length, struct sockaddr* addr = 0, socklen_t* adrlen = 0, int flags = 0);
04324 
04333     int recvFrom(void* buffer, int length, SocketAddr& addr, int flags = 0);
04334 
04342     int recv(void* buffer, int length, int flags = 0);
04343 
04350     virtual int readData(void* buffer, int length);
04351 
04360     bool select(bool* readok, bool* writeok, bool* except, struct timeval* timeout = 0);
04361 
04370     bool select(bool* readok, bool* writeok, bool* except, int64_t timeout);
04371 
04377     bool installFilter(SocketFilter* filter);
04378 
04384     void removeFilter(SocketFilter* filter, bool delobj = false);
04385 
04389     void clearFilters();
04390 
04397     virtual void timerTick(const Time& when);
04398 
04406     static bool createPair(Socket& sock1, Socket& sock2, int domain = AF_UNIX);
04407 
04408 protected:
04409 
04413     void copyError();
04414 
04421     bool checkError(int retcode, bool strict = false);
04422 
04432     bool applyFilters(void* buffer, int length, int flags, const struct sockaddr* addr = 0, socklen_t adrlen = 0);
04433 
04434     SOCKET m_handle;
04435     ObjList m_filters;
04436 };
04437 
04443 class YATE_API SysUsage
04444 {
04445 public:
04449     enum Type {
04450         WallTime,
04451         UserTime,
04452         KernelTime
04453     };
04454 
04458     static void init();
04459 
04464     static u_int64_t startTime();
04465 
04471     static u_int64_t usecRunTime(Type type = WallTime);
04472 
04478     static u_int64_t msecRunTime(Type type = WallTime);
04479 
04485     static u_int32_t secRunTime(Type type = WallTime);
04486 
04492     static double runTime(Type type = WallTime);
04493 
04494 };
04495 
04496 }; // namespace TelEngine
04497 
04498 #endif /* __YATECLASS_H */
04499 
04500 /* vi: set ts=8 sw=4 sts=4 noet: */

Generated on Mon Oct 22 07:43:07 2007 for Yate by  doxygen 1.5.2