Yate: yatengine.h Source File

Yate

- Main Page
- Namespaces
- Classes
- Files

- File List

yatengine.h
1
22 #ifndef __YATENGINE_H
23 #define __YATENGINE_H
24
25 #ifndef __cplusplus
26 #error C++ is required
27 #endif
28
29 #include <yateclass.h>
30
34 namespace TelEngine {
35
40 class YATE_API Configuration : public String
41 {
42 YNOCOPY(Configuration); // no automatic copies please
43 public:
47 Configuration();
48
54 explicit Configuration(const char* filename, bool warn = true);
55
59 inline Configuration& operator=(const String& value)
60 { String::operator=(value); return *this; }
61
66 inline unsigned int sections() const
67 { return m_sections.length(); }
68
73 inline unsigned int count() const
74 { return m_sections.count(); }
75
81 NamedList* getSection(unsigned int index) const;
82
88 NamedList* getSection(const String& sect) const;
89
96 NamedString* getKey(const String& sect, const String& key) const;
97
105 const char* getValue(const String& sect, const String& key, const char* defvalue = 0) const;
106
118 int getIntValue(const String& sect, const String& key, int defvalue = 0,
119 int minvalue = INT_MIN, int maxvalue = INT_MAX, bool clamp = true) const;
120
129 int getIntValue(const String& sect, const String& key, const TokenDict* tokens, int defvalue = 0) const;
130
142 int64_t getInt64Value(const String& sect, const String& key, int64_t defvalue = 0,
143 int64_t minvalue = LLONG_MIN, int64_t maxvalue = LLONG_MAX, bool clamp = true) const;
144
152 double getDoubleValue(const String& sect, const String& key, double defvalue = 0.0) const;
153
161 bool getBoolValue(const String& sect, const String& key, bool defvalue = false) const;
162
167 void clearSection(const char* sect = 0);
168
174 NamedList* createSection(const String& sect);
175
181 void clearKey(const String& sect, const String& key);
182
189 void addValue(const String& sect, const char* key, const char* value = 0);
190
197 void setValue(const String& sect, const char* key, const char* value = 0);
198
205 void setValue(const String& sect, const char* key, int value);
206
213 void setValue(const String& sect, const char* key, bool value);
214
220 bool load(bool warn = true);
221
226 bool save() const;
227
228 private:
229 ObjList *getSectHolder(const String& sect) const;
230 ObjList *makeSectHolder(const String& sect);
231 bool loadFile(const char* file, String sect, unsigned int depth, bool warn);
232 ObjList m_sections;
233 };
234
239 class YATE_API SharedVars : public Mutex
240 {
241 public:
245 inline SharedVars()
246 : Mutex(false,"SharedVars"), m_vars("")
247 { }
248
254 void get(const String& name, String& rval);
255
261 void set(const String& name, const char* val);
262
269 bool create(const String& name, const char* val = 0);
270
275 void clear(const String& name);
276
282 bool exists(const String& name);
283
290 unsigned int inc(const String& name, unsigned int wrap = 0);
291
298 unsigned int dec(const String& name, unsigned int wrap = 0);
299
300 private:
301 NamedList m_vars;
302 };
303
304 class MessageDispatcher;
305 class MessageRelay;
306 class Engine;
307
312 class YATE_API Message : public NamedList
313 {
314 friend class MessageDispatcher;
315 public:
323 explicit Message(const char* name, const char* retval = 0, bool broadcast = false);
324
330 Message(const Message& original);
331
338 Message(const Message& original, bool broadcast);
339
343 ~Message();
344
350 virtual void* getObject(const String& name) const;
351
356 inline String& retValue()
357 { return m_return; }
358
363 inline const String& retValue() const
364 { return m_return; }
365
370 inline RefObject* userData() const
371 { return m_data; }
372
379 void userData(RefObject* data);
380
386 inline void* userObject(const String& name) const
387 { return m_data ? m_data->getObject(name) : 0; }
388
389
395 inline void setNotify(bool notify = true)
396 { m_notify = notify; }
397
402 inline bool broadcast() const
403 { return m_broadcast; }
404
409 inline Time& msgTime()
410 { return m_time; }
411
416 inline const Time& msgTime() const
417 { return m_time; }
418
422 inline Message& operator=(const char* value)
423 { String::operator=(value); return *this; }
424
430 String encode(const char* id) const;
431
438 String encode(bool received, const char* id) const;
439
448 int decode(const char* str, String& id);
449
459 int decode(const char* str, bool& received, const char* id);
460
461 protected:
468 virtual void dispatched(bool accepted);
469
470 private:
471 Message(); // no default constructor please
472 Message& operator=(const Message& value); // no assignment please
473 String m_return;
474 Time m_time;
475 RefObject* m_data;
476 bool m_notify;
477 bool m_broadcast;
478 void commonEncode(String& str) const;
479 int commonDecode(const char* str, int offs);
480 };
481
488 class YATE_API MessageHandler : public String
489 {
490 friend class MessageDispatcher;
491 YNOCOPY(MessageHandler); // no automatic copies please
492 public:
500 explicit MessageHandler(const char* name, unsigned priority = 100,
501 const char* trackName = 0, bool addPriority = true);
502
506 virtual ~MessageHandler();
507
511 virtual void destruct();
512
518 virtual bool received(Message& msg) = 0;
519
524 inline unsigned priority() const
525 { return m_priority; }
526
531 inline const String& trackName() const
532 { return m_trackName; }
533
539 inline void trackName(const char* name)
540 { if (!m_dispatcher) m_trackName = name; }
541
546 inline NamedCounter* objectsCounter() const
547 { return m_counter; }
548
552 inline const NamedString* filter() const
553 { return m_filter; }
554
560 void setFilter(NamedString* filter);
561
567 inline void setFilter(const char* name, const char* value)
568 { setFilter(new NamedString(name,value)); }
569
573 void clearFilter();
574
575 protected:
580 void cleanup();
581
587 virtual bool receivedInternal(Message& msg);
588
592 void safeNowInternal();
593
594 private:
595 String m_trackName;
596 unsigned m_priority;
597 int m_unsafe;
598 MessageDispatcher* m_dispatcher;
599 NamedString* m_filter;
600 NamedCounter* m_counter;
601 };
602
607 class YATE_API MessageReceiver : public GenObject
608 {
609 public:
616 virtual bool received(Message& msg, int id) = 0;
617 };
618
623 class YATE_API MessageRelay : public MessageHandler
624 {
625 YNOCOPY(MessageRelay); // no automatic copies please
626 public:
636 inline MessageRelay(const char* name, MessageReceiver* receiver, int id,
637 int priority = 100, const char* trackName = 0, bool addPriority = true)
638 : MessageHandler(name,priority,trackName,addPriority),
639 m_receiver(receiver), m_id(id)
640 { }
641
648 virtual bool received(Message& msg)
649 { return m_receiver && m_receiver->received(msg,m_id); }
650
655 inline int id() const
656 { return m_id; }
657
663 virtual bool receivedInternal(Message& msg);
664
665 private:
666 MessageReceiver* m_receiver;
667 int m_id;
668 };
669
676 class YATE_API MessageNotifier
677 {
678 public:
682 virtual ~MessageNotifier();
683
689 virtual void dispatched(const Message& msg, bool handled) = 0;
690 };
691
698 class YATE_API MessagePostHook : public RefObject, public MessageNotifier
699 {
700 };
701
708 class YATE_API MessageDispatcher : public GenObject, public Mutex
709 {
710 friend class Engine;
711 YNOCOPY(MessageDispatcher); // no automatic copies please
712 public:
717 MessageDispatcher(const char* trackParam = 0);
718
722 ~MessageDispatcher();
723
728 inline const String& trackParam() const
729 { return m_trackParam; }
730
739 bool install(MessageHandler* handler);
740
746 bool uninstall(MessageHandler* handler);
747
759 bool dispatch(Message& msg);
760
766 bool enqueue(Message* msg);
767
771 void dequeue();
772
777 bool dequeueOne();
778
783 inline void warnTime(u_int64_t usec)
784 { m_warnTime = usec; }
785
789 inline void clear()
790 { m_handlers.clear(); m_hookAppend = &m_hooks; m_hooks.clear(); }
791
796 unsigned int messageCount();
797
802 unsigned int handlerCount();
803
808 unsigned int postHookCount();
809
814 u_int64_t enqueueCount() const
815 { return m_enqueueCount; }
816
821 u_int64_t dequeueCount() const
822 { return m_dequeueCount; }
823
828 u_int64_t dispatchCount() const
829 { return m_dispatchCount; }
830
835 u_int64_t queuedMax() const
836 { return m_queuedMax; }
837
843 u_int64_t messageAge(bool usec = false) const
844 { return usec ? m_msgAvgAge : ((m_msgAvgAge + 500) / 1000); }
845
853 void getStats(u_int64_t& enqueued, u_int64_t& dequeued, u_int64_t& dispatched, u_int64_t& queueMax);
854
860 void setHook(MessagePostHook* hook, bool remove = false);
861
862 protected:
867 inline void trackParam(const char* paramName)
868 { m_trackParam = paramName; }
869
870 private:
871 ObjList m_handlers;
872 ObjList m_messages;
873 ObjList m_hooks;
874 Mutex m_hookMutex;
875 ObjList* m_msgAppend;
876 ObjList* m_hookAppend;
877 String m_trackParam;
878 unsigned int m_changes;
879 u_int64_t m_warnTime;
880 u_int64_t m_enqueueCount;
881 u_int64_t m_dequeueCount;
882 u_int64_t m_dispatchCount;
883 u_int64_t m_queuedMax;
884 u_int64_t m_msgAvgAge;
885 int m_hookCount;
886 bool m_hookHole;
887 };
888
893 class YATE_API MessageHook : public RefObject
894 {
895 public:
901 virtual bool enqueue(Message* msg) = 0;
902
906 virtual void clear() = 0;
907
913 virtual bool matchesFilter(const Message& msg) = 0;
914 };
915
916
922 class YATE_API MessageQueue : public MessageHook, public Mutex
923 {
924 friend class Engine;
925 public:
931 MessageQueue(const char* hookName, int numWorkers = 0);
932
936 ~MessageQueue();
937
943 virtual bool enqueue(Message* msg);
944
949 bool dequeue();
950
956 void addFilter(const char* name, const char* value);
957
962 void removeFilter(const String& name);
963
967 virtual void clear();
968
973 void removeThread(Thread* thread);
974
979 inline unsigned int count() const
980 { return m_count; }
981
986 inline const NamedList& getFilters() const
987 { return m_filters; }
988
994 virtual bool matchesFilter(const Message& msg);
995 protected:
996
1002 virtual void received(Message& msg);
1003
1004 private:
1005 NamedList m_filters;
1006 ObjList m_messages;
1007 ObjList m_workers;
1008 ObjList* m_append;
1009 unsigned int m_count;
1010 };
1011
1012
1023 class YATE_API Plugin : public GenObject, public DebugEnabler
1024 {
1025 public:
1031 explicit Plugin(const char* name, bool earlyInit = false);
1032
1038 virtual ~Plugin();
1039
1044 virtual const String& toString() const
1045 { return m_name; }
1046
1052 virtual void* getObject(const String& name) const;
1053
1057 virtual void initialize() = 0;
1058
1063 virtual bool isBusy() const
1064 { return false; }
1065
1070 inline const String& name() const
1071 { return m_name; }
1072
1077 inline NamedCounter* objectsCounter() const
1078 { return m_counter; }
1079
1084 bool earlyInit() const
1085 { return m_early; }
1086
1087 private:
1088 Plugin(); // no default constructor please
1089 String m_name;
1090 NamedCounter* m_counter;
1091 bool m_early;
1092 };
1093
1094 #if 0 /* for documentation generator */
1095
1099 void INIT_PLUGIN(class pclass);
1100
1106 bool UNLOAD_PLUGIN(bool unloadNow);
1107 #endif
1108
1109 #define INIT_PLUGIN(pclass) static pclass __plugin
1110 #ifdef DISABLE_UNLOAD
1111 #define UNLOAD_PLUGIN(arg) static bool _unused_unload(bool arg)
1112 #else
1113 #ifdef _WINDOWS
1114 #define UNLOAD_PLUGIN(arg) extern "C" __declspec(dllexport) bool _unload(bool arg)
1115 #else
1116 #define UNLOAD_PLUGIN(arg) extern "C" bool _unload(bool arg)
1117 #endif
1118 #endif
1119
1126 class YATE_API EngineCheck
1127 {
1128 public:
1132 virtual ~EngineCheck()
1133 { }
1134
1141 virtual bool check(const ObjList* cmds) = 0;
1142
1147 static void setChecker(EngineCheck* ptr = 0);
1148 };
1149
1153 typedef int (*EngineLoop)();
1154
1161 class YATE_API Engine
1162 {
1163 friend class EnginePrivate;
1164 friend class EngineCommand;
1165 YNOCOPY(Engine); // no automatic copies please
1166 public:
1170 enum RunMode {
1171 Stopped = 0,
1172 Console = 1,
1173 Server = 2,
1174 Client = 3,
1175 ClientProxy = 4,
1176 };
1177
1178 enum CallAccept {
1179 Accept = 0,
1180 Partial = 1,
1181 Congestion = 2,
1182 Reject = 3,
1183 };
1184
1191 enum PluginMode {
1192 LoadFail = 0,
1193 LoadLate,
1194 LoadEarly
1195 };
1196
1207 static int main(int argc, const char** argv, const char** env,
1208 RunMode mode = Console, EngineLoop loop = 0, bool fail = false);
1209
1215 static void help(bool client, bool errout = false);
1216
1221 int engineInit();
1222
1227 int engineCleanup();
1228
1233 int run();
1234
1239 static Engine* self();
1240
1245 static RunMode mode()
1246 { return s_mode; }
1247
1252 inline static CallAccept accept() {
1253 return (s_congestion && (s_accept < Congestion)) ? Congestion : s_accept;
1254 }
1255
1260 inline static void setAccept(CallAccept ca) {
1261 s_accept = ca;
1262 }
1263
1268 inline static const TokenDict* getCallAcceptStates() {
1269 return s_callAccept;
1270 }
1271
1276 static void setCongestion(const char* reason = 0);
1277
1282 static unsigned int getCongestion()
1283 { return s_congestion; }
1284
1289 inline static bool clientMode()
1290 { return (s_mode == Client) || (s_mode == ClientProxy); }
1291
1298 static bool Register(const Plugin* plugin, bool reg = true);
1299
1304 inline static const String& nodeName()
1305 { return s_node; }
1306
1311 inline static const String& sharedPath()
1312 { return s_shrpath; }
1313
1320 static String configFile(const char* name, bool user = false);
1321
1327 static const String& configPath(bool user = false);
1328
1333 inline static const String& configSuffix()
1334 { return s_cfgsuffix; }
1335
1339 inline static const String& modulePath()
1340 { return s_modpath; }
1341
1347 static void extraPath(const String& path);
1348
1355 static void userPath(const String& path);
1356
1361 inline static const String& moduleSuffix()
1362 { return s_modsuffix; }
1363
1368 static const char* pathSeparator();
1369
1377 static const Configuration& config();
1378
1383 static unsigned int runId();
1384
1389 inline static const NamedList& runParams()
1390 { return s_params; }
1391
1395 static void init();
1396
1402 static bool init(const String& name);
1403
1408 static void halt(unsigned int code);
1409
1416 static bool restart(unsigned int code, bool gracefull = false);
1417
1422 static bool started()
1423 { return s_started; }
1424
1429 static bool exiting()
1430 { return (s_haltcode != -1); }
1431
1437 static bool install(MessageHandler* handler);
1438
1444 static bool uninstall(MessageHandler* handler);
1445
1452 static bool enqueue(Message* msg, bool skipHooks = false);
1453
1461 inline static bool enqueue(const char* name, bool broadcast = false)
1462 { return name && *name && enqueue(new Message(name,0,broadcast)); }
1463
1469 static bool dispatch(Message* msg);
1470
1476 static bool dispatch(Message& msg);
1477
1485 static bool dispatch(const char* name, bool broadcast = false);
1486
1492 inline void setHook(MessagePostHook* hook, bool remove = false)
1493 { m_dispatcher.setHook(hook,remove); }
1494
1499 inline static const String& trackParam()
1500 { return s_self ? s_self->m_dispatcher.trackParam() : String::empty(); }
1501
1507 static bool installHook(MessageHook* hook);
1508
1513 static void uninstallHook(MessageHook* hook);
1514
1519 int usedPlugins();
1520
1525 inline unsigned int messageCount()
1526 { return m_dispatcher.messageCount(); }
1527
1532 inline unsigned int handlerCount()
1533 { return m_dispatcher.handlerCount(); }
1534
1539 inline unsigned int postHookCount()
1540 { return m_dispatcher.postHookCount(); }
1541
1546 inline unsigned int messageRate() const
1547 { return m_messageRate; }
1548
1553 inline unsigned int messageMaxRate() const
1554 { return m_maxMsgRate; }
1555
1561 unsigned int messageAge(bool usec = false) const
1562 { return (unsigned int)m_dispatcher.messageAge(usec); }
1563
1571 inline void getStats(u_int64_t& enqueued, u_int64_t& dequeued, u_int64_t& dispatched, u_int64_t& queueMax)
1572 { m_dispatcher.getStats(enqueued,dequeued,dispatched,queueMax); }
1573
1579 bool loadPluginDir(const String& relPath);
1580
1585 static void pluginMode(PluginMode mode);
1586
1592 static const ObjList* events(const String& type);
1593
1598 static void clearEvents(const String& type);
1599
1604 static SharedVars& sharedVars();
1605
1612 static void buildCmdLine(String& line);
1613
1622 static void initLibrary(const String& line, String* output = 0);
1623
1629 static int cleanupLibrary();
1630
1631 protected:
1636 ~Engine();
1637
1645 bool loadPlugin(const char* file, bool local = false, bool nounload = false);
1646
1650 void loadPlugins();
1651
1655 void initPlugins();
1656
1657 private:
1658 Engine();
1659 void internalStatisticsStart();
1660 void tryPluginFile(const String& name, const String& path, bool defload);
1661 ObjList m_libs;
1662 MessageDispatcher m_dispatcher;
1663 uint64_t m_dispatchedLast;
1664 unsigned int m_messageRate;
1665 unsigned int m_maxMsgRate;
1666 bool m_rateCongested;
1667 bool m_queueCongested;
1668 bool m_ageCongested;
1669 static Engine* s_self;
1670 static String s_node;
1671 static String s_shrpath;
1672 static String s_cfgsuffix;
1673 static String s_modpath;
1674 static String s_modsuffix;
1675 static ObjList s_extramod;
1676 static NamedList s_params;
1677 static int s_haltcode;
1678 static RunMode s_mode;
1679 static bool s_started;
1680 static unsigned int s_congestion;
1681 static CallAccept s_accept;
1682 static const TokenDict s_callAccept[];
1683 };
1684
1685 }; // namespace TelEngine
1686
1687 #endif /* __YATENGINE_H */
1688
1689 /* vi: set ts=8 sw=4 sts=4 noet: */
TelEngine::Engine::messageAge
unsigned int messageAge(bool usec=false) const
Definition: yatengine.h:1561
TelEngine::MessageRelay::received
virtual bool received(Message &msg)
Definition: yatengine.h:648
TelEngine::Engine::enqueue
static bool enqueue(const char *name, bool broadcast=false)
Definition: yatengine.h:1461
TelEngine::Engine::messageMaxRate
unsigned int messageMaxRate() const
Definition: yatengine.h:1553
TelEngine::Engine::mode
static RunMode mode()
Definition: yatengine.h:1245
TelEngine::EngineCheck
Engine checker interface.
Definition: yatengine.h:1126
TelEngine::MessagePostHook
Post-dispatching message hook that can be added to a list.
Definition: yatengine.h:698
TelEngine::RefObject
Definition: yateclass.h:950
TelEngine::MessageDispatcher::enqueueCount
u_int64_t enqueueCount() const
Definition: yatengine.h:814
TelEngine::MessageNotifier
Post-dispatching message hook.
Definition: yatengine.h:676
TelEngine::Engine::messageRate
unsigned int messageRate() const
Definition: yatengine.h:1546
TelEngine::MessageQueue::count
unsigned int count() const
Definition: yatengine.h:979
TelEngine::Thread
Thread support class.
Definition: yateclass.h:5604
TelEngine::MessageDispatcher::trackParam
const String & trackParam() const
Definition: yatengine.h:728
TelEngine::MessageHandler::priority
unsigned priority() const
Definition: yatengine.h:524
TelEngine::Message::retValue
String & retValue()
Definition: yatengine.h:356
TelEngine::Engine::nodeName
static const String & nodeName()
Definition: yatengine.h:1304
TelEngine::Engine::accept
static CallAccept accept()
Definition: yatengine.h:1252
TelEngine::Message::msgTime
const Time & msgTime() const
Definition: yatengine.h:416
TelEngine::Message::userObject
void * userObject(const String &name) const
Definition: yatengine.h:386
TelEngine::Engine::postHookCount
unsigned int postHookCount()
Definition: yatengine.h:1539
TelEngine::Engine::getCallAcceptStates
static const TokenDict * getCallAcceptStates()
Definition: yatengine.h:1268
TelEngine::Configuration
Configuration file handling.
Definition: yatengine.h:40
TelEngine::MessageHandler::objectsCounter
NamedCounter * objectsCounter() const
Definition: yatengine.h:546
TelEngine::Configuration::sections
unsigned int sections() const
Definition: yatengine.h:66
TelEngine::MessageReceiver
A multiple message receiver.
Definition: yatengine.h:607
TelEngine::MessageRelay::MessageRelay
MessageRelay(const char *name, MessageReceiver *receiver, int id, int priority=100, const char *trackName=0, bool addPriority=true)
Definition: yatengine.h:636
TelEngine::EngineLoop
int(* EngineLoop)()
Definition: yatengine.h:1153
TelEngine::Engine::setAccept
static void setAccept(CallAccept ca)
Definition: yatengine.h:1260
TelEngine::MessageDispatcher
A message dispatching hub.
Definition: yatengine.h:708
TelEngine::MessageRelay
A message handler relay.
Definition: yatengine.h:623
TelEngine::Engine::sharedPath
static const String & sharedPath()
Definition: yatengine.h:1311
TelEngine::Configuration::operator=
Configuration & operator=(const String &value)
Definition: yatengine.h:59
TelEngine::Message::msgTime
Time & msgTime()
Definition: yatengine.h:409
TelEngine::MessageDispatcher::warnTime
void warnTime(u_int64_t usec)
Definition: yatengine.h:783
TelEngine::MessageRelay::id
int id() const
Definition: yatengine.h:655
TelEngine::String::operator=
String & operator=(const String &value)
Definition: yateclass.h:2300
TelEngine::Engine::PluginMode
PluginMode
Definition: yatengine.h:1191
TelEngine::MessageQueue
A message queue.
Definition: yatengine.h:922
TelEngine::destruct
void destruct(GenObject *obj)
Definition: yateclass.h:934
TelEngine::Engine::exiting
static bool exiting()
Definition: yatengine.h:1429
TelEngine::Engine::configSuffix
static const String & configSuffix()
Definition: yatengine.h:1333
TelEngine::Engine::runParams
static const NamedList & runParams()
Definition: yatengine.h:1389
TelEngine::Engine::trackParam
static const String & trackParam()
Definition: yatengine.h:1499
TelEngine::Time
A time holding class.
Definition: yateclass.h:3611
TelEngine::Message::retValue
const String & retValue() const
Definition: yatengine.h:363
TelEngine::DebugEnabler
A holder for a debug level.
Definition: yateclass.h:309
TelEngine::Message
A message container class.
Definition: yatengine.h:312
TelEngine::Engine::modulePath
static const String & modulePath()
Definition: yatengine.h:1339
TelEngine::Engine::getStats
void getStats(u_int64_t &enqueued, u_int64_t &dequeued, u_int64_t &dispatched, u_int64_t &queueMax)
Definition: yatengine.h:1571
TelEngine::SharedVars
Atomic access and operations to shared variables.
Definition: yatengine.h:239
TelEngine::Engine::setHook
void setHook(MessagePostHook *hook, bool remove=false)
Definition: yatengine.h:1492
TelEngine::MessageDispatcher::messageAge
u_int64_t messageAge(bool usec=false) const
Definition: yatengine.h:843
TelEngine::Message::userData
RefObject * userData() const
Definition: yatengine.h:370
TelEngine::Engine::clientMode
static bool clientMode()
Definition: yatengine.h:1289
TelEngine::Plugin::toString
virtual const String & toString() const
Definition: yatengine.h:1044
TelEngine::MessageHandler::setFilter
void setFilter(const char *name, const char *value)
Definition: yatengine.h:567
TelEngine::NamedString
A named string class.
Definition: yateclass.h:3186
TelEngine::Engine::handlerCount
unsigned int handlerCount()
Definition: yatengine.h:1532
TelEngine::MessageHandler::filter
const NamedString * filter() const
Definition: yatengine.h:552
TelEngine::MessageDispatcher::trackParam
void trackParam(const char *paramName)
Definition: yatengine.h:867
TelEngine::MessageDispatcher::queuedMax
u_int64_t queuedMax() const
Definition: yatengine.h:835
TelEngine::SharedVars::SharedVars
SharedVars()
Definition: yatengine.h:245
TelEngine::NamedList
A named string container class.
Definition: yateclass.h:4628
TelEngine::INIT_PLUGIN
void INIT_PLUGIN(class pclass)
TelEngine::MessageHandler
A message handler.
Definition: yatengine.h:488
TelEngine::MessageDispatcher::dequeueCount
u_int64_t dequeueCount() const
Definition: yatengine.h:821
TelEngine::MessageDispatcher::clear
void clear()
Definition: yatengine.h:789
TelEngine::Configuration::count
unsigned int count() const
Definition: yatengine.h:73
TelEngine::MessageDispatcher::dispatchCount
u_int64_t dispatchCount() const
Definition: yatengine.h:828
TelEngine
Definition: yateclass.h:217
TelEngine::Message::broadcast
bool broadcast() const
Definition: yatengine.h:402
TelEngine::String
A C-style string handling class.
Definition: yateclass.h:1907
TelEngine::TokenDict
Definition: yateclass.h:683
TelEngine::Message::setNotify
void setNotify(bool notify=true)
Definition: yatengine.h:395
TelEngine::Plugin::name
const String & name() const
Definition: yatengine.h:1070
TelEngine::Engine::moduleSuffix
static const String & moduleSuffix()
Definition: yatengine.h:1361
TelEngine::ObjList
An object list class.
Definition: yateclass.h:1230
TelEngine::UNLOAD_PLUGIN
bool UNLOAD_PLUGIN(bool unloadNow)
TelEngine::YNOCOPY
void YNOCOPY(class type)
TelEngine::Engine::getCongestion
static unsigned int getCongestion()
Definition: yatengine.h:1282
TelEngine::MessageQueue::getFilters
const NamedList & getFilters() const
Definition: yatengine.h:986
TelEngine::String::empty
static const String & empty()
TelEngine::Plugin::isBusy
virtual bool isBusy() const
Definition: yatengine.h:1063
TelEngine::MessageHandler::trackName
const String & trackName() const
Definition: yatengine.h:531
TelEngine::Message::operator=
Message & operator=(const char *value)
Definition: yatengine.h:422
TelEngine::Plugin
Plugin support.
Definition: yatengine.h:1023
TelEngine::Engine::RunMode
RunMode
Definition: yatengine.h:1170
TelEngine::Mutex
Mutex support.
Definition: yateclass.h:5206
TelEngine::Engine
Engine globals.
Definition: yatengine.h:1161
TelEngine::GenObject
Definition: yateclass.h:831
TelEngine::MessageHandler::trackName
void trackName(const char *name)
Definition: yatengine.h:539
TelEngine::Engine::started
static bool started()
Definition: yatengine.h:1422
TelEngine::Engine::messageCount
unsigned int messageCount()
Definition: yatengine.h:1525
TelEngine::EngineCheck::~EngineCheck
virtual ~EngineCheck()
Definition: yatengine.h:1132
TelEngine::Plugin::earlyInit
bool earlyInit() const
Definition: yatengine.h:1084
TelEngine::MessageHook
Abstract message hook.
Definition: yatengine.h:893
TelEngine::Plugin::objectsCounter
NamedCounter * objectsCounter() const
Definition: yatengine.h:1077
TelEngine::Client
Class that runs the User Interface.
Definition: yatecbase.h:993
TelEngine::NamedCounter
Atomic counter with name.
Definition: yateclass.h:3307