yatengine.h

00001 /*
00002  * yatengine.h
00003  * This file is part of the YATE Project http://YATE.null.ro
00004  *
00005  * Engine, plugins and messages related classes
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 __YATENGINE_H
00026 #define __YATENGINE_H
00027 
00028 #ifndef __cplusplus
00029 #error C++ is required
00030 #endif
00031 
00032 #include <yateclass.h>
00033         
00037 namespace TelEngine {
00038 
00043 class YATE_API Configuration : public String
00044 {
00045 public:
00049     Configuration();
00050 
00055     Configuration(const char* filename);
00056 
00060     inline Configuration& operator=(const String& value)
00061         { String::operator=(value); return *this; }
00062 
00067     inline unsigned int sections() const
00068         { return m_sections.length(); }
00069 
00075     NamedList* getSection(unsigned int index) const;
00076 
00082     NamedList* getSection(const String& sect) const;
00083 
00090     NamedString* getKey(const String& sect, const String& key) const;
00091 
00099     const char* getValue(const String& sect, const String& key, const char* defvalue = 0) const;
00100 
00108     int getIntValue(const String& sect, const String& key, int defvalue = 0) const;
00109 
00118     int getIntValue(const String& sect, const String& key, const TokenDict* tokens, int defvalue = 0) const;
00119 
00127     double getDoubleValue(const String& sect, const String& key, double defvalue = 0.0) const;
00128 
00136     bool getBoolValue(const String& sect, const String& key, bool defvalue = false) const;
00137 
00142     void clearSection(const char* sect = 0);
00143 
00148     inline void createSection(const String& sect)
00149         { if (sect) makeSectHolder(sect); }
00150 
00156     void clearKey(const String& sect, const String& key);
00157 
00164     void addValue(const String& sect, const char* key, const char* value = 0);
00165 
00172     void setValue(const String& sect, const char* key, const char* value = 0);
00173 
00180     void setValue(const String& sect, const char* key, int value);
00181 
00188     void setValue(const String& sect, const char* key, bool value);
00189 
00194     bool load();
00195 
00200     bool save() const;
00201 
00202 private:
00203     Configuration(const Configuration& value); // no copy constructor
00204     Configuration& operator=(const Configuration& value); // no assignment please
00205     ObjList *getSectHolder(const String& sect) const;
00206     ObjList *makeSectHolder(const String& sect);
00207     ObjList m_sections;
00208 };
00209 
00210 class MessageDispatcher;
00211 
00216 class YATE_API Message : public NamedList
00217 {
00218     friend class MessageDispatcher;
00219 public:
00226     Message(const char* name, const char* retval = 0);
00227 
00233     Message(const Message& original);
00234 
00238     ~Message();
00239 
00245     virtual void* getObject(const String& name) const;
00246 
00251     inline String& retValue()
00252         { return m_return; }
00253 
00258     inline const String& retValue() const
00259         { return m_return; }
00260 
00265     inline RefObject* userData() const
00266         { return m_data; }
00267 
00274     void userData(RefObject* data);
00275 
00281     inline void* userObject(const String& name) const
00282         { return m_data ? m_data->getObject(name) : 0; }
00283 
00284 
00290     inline void setNotify(bool notify = true)
00291         { m_notify = notify; }
00292 
00297     inline Time& msgTime()
00298         { return m_time; }
00299 
00304     inline const Time& msgTime() const
00305         { return m_time; }
00306 
00310     inline Message& operator=(const char* value)
00311         { String::operator=(value); return *this; }
00312 
00318     String encode(const char* id) const;
00319 
00326     String encode(bool received, const char* id) const;
00327 
00336     int decode(const char* str, String& id);
00337 
00347     int decode(const char* str, bool& received, const char* id);
00348 
00349 protected:
00356     virtual void dispatched(bool accepted);
00357 
00358 private:
00359     Message(); // no default constructor please
00360     Message& operator=(const Message& value); // no assignment please
00361     String m_return;
00362     Time m_time;
00363     RefObject* m_data;
00364     bool m_notify;
00365     void commonEncode(String& str) const;
00366     int commonDecode(const char* str, int offs);
00367 };
00368 
00375 class YATE_API MessageHandler : public String
00376 {
00377     friend class MessageDispatcher;
00378 public:
00384     MessageHandler(const char* name, unsigned priority = 100);
00385 
00389     virtual ~MessageHandler();
00390 
00394     virtual void destruct();
00395 
00401     virtual bool received(Message& msg) = 0;
00402 
00407     inline unsigned priority() const
00408         { return m_priority; }
00409 
00413     inline const NamedString* filter() const
00414         { return m_filter; }
00415 
00421     void setFilter(NamedString* filter);
00422 
00428     inline void setFilter(const char* name, const char* value)
00429         { setFilter(new NamedString(name,value)); }
00430 
00434     void clearFilter();
00435 
00436 private:
00437     void cleanup();
00438     unsigned m_priority;
00439     MessageDispatcher* m_dispatcher;
00440     NamedString* m_filter;
00441 };
00442 
00447 class YATE_API MessageReceiver : public GenObject
00448 {
00449 public:
00456     virtual bool received(Message& msg, int id) = 0;
00457 };
00458 
00463 class YATE_API MessageRelay : public MessageHandler
00464 {
00465 public:
00473     MessageRelay(const char* name, MessageReceiver* receiver, int id, int priority = 100)
00474         : MessageHandler(name,priority), m_receiver(receiver), m_id(id) { }
00475 
00481     virtual bool received(Message& msg)
00482         { return m_receiver ? m_receiver->received(msg,m_id) : false; }
00483 
00484 private:
00485     MessageReceiver* m_receiver;
00486     int m_id;
00487 };
00488 
00495 class YATE_API MessageNotifier
00496 {
00497 public:
00501     virtual ~MessageNotifier();
00502 
00508     virtual void dispatched(const Message& msg, bool handled) = 0;
00509 };
00510 
00517 class YATE_API MessagePostHook : public GenObject, public MessageNotifier
00518 {
00519 };
00520 
00527 class YATE_API MessageDispatcher : public GenObject
00528 {
00529 public:
00533     MessageDispatcher();
00534 
00538     ~MessageDispatcher();
00539 
00545     bool install(MessageHandler* handler);
00546 
00552     bool uninstall(MessageHandler* handler);
00553 
00559     bool dispatch(Message& msg);
00560 
00566     bool enqueue(Message* msg);
00567 
00571     void dequeue();
00572 
00577     bool dequeueOne();
00578 
00583     inline void warnTime(u_int64_t usec)
00584         { m_warnTime = usec; }
00585 
00589     inline void clear()
00590         { m_handlers.clear(); m_hooks.clear(); }
00591 
00596     unsigned int messageCount();
00597 
00602     unsigned int handlerCount();
00603 
00609     void setHook(MessagePostHook* hook, bool remove = false);
00610 
00611 private:
00612     ObjList m_handlers;
00613     ObjList m_messages;
00614     ObjList m_hooks;
00615     Mutex m_mutex;
00616     unsigned int m_changes;
00617     u_int64_t m_warnTime;
00618 };
00619 
00630 class YATE_API Plugin : public GenObject
00631 {
00632 public:
00637     Plugin(const char* name);
00638 
00643     Plugin();
00644 
00650     virtual ~Plugin();
00651 
00657     virtual void* getObject(const String& name) const;
00658 
00662     virtual void initialize() = 0;
00663 
00668     virtual bool isBusy() const
00669         { return false; }
00670 };
00671 
00672 #if 0 /* for documentation generator */
00673 
00677 void INIT_PLUGIN(class pclass);
00678 #endif
00679 
00680 #define INIT_PLUGIN(pclass) static pclass __plugin
00681 
00688 class YATE_API Engine
00689 {
00690     friend class EnginePrivate;
00691 public:
00695     enum RunMode {
00696         Stopped = 0,
00697         Console = 1,
00698         Client = 2,
00699         Server = 3,
00700     };
00701 
00711     static int main(int argc, const char** argv, const char** env,
00712         RunMode mode = Console, bool fail = false);
00713 
00719     static void help(bool client, bool errout = false);
00720 
00725     int run();
00726 
00731     static Engine* self();
00732 
00737     static RunMode mode()
00738         { return s_mode; }
00739 
00744     inline static bool clientMode()
00745         { return s_mode == Client; }
00746 
00753     static bool Register(const Plugin* plugin, bool reg = true);
00754 
00761     static String configFile(const char* name, bool user = false);
00762 
00767     inline static String& configPath()
00768         { return s_cfgpath; }
00769 
00774     inline static String& configSuffix()
00775         { return s_cfgsuffix; }
00776 
00780     inline static String& modulePath()
00781         { return s_modpath; }
00782 
00788     static void extraPath(const String& path);
00789 
00794     inline static String& moduleSuffix()
00795         { return s_modsuffix; }
00796 
00801     static const char* pathSeparator();
00802 
00810     static const Configuration& config();
00811 
00816     static unsigned int runId();
00817 
00821     static void init();
00822 
00827     static void halt(unsigned int code);
00828 
00835     static bool restart(unsigned int code, bool gracefull = false);
00836 
00841     static bool exiting()
00842         { return (s_haltcode != -1); }
00843 
00849     static bool install(MessageHandler* handler);
00850 
00856     static bool uninstall(MessageHandler* handler);
00857 
00863     static bool enqueue(Message* msg);
00864 
00871     inline static bool enqueue(const char* name)
00872         { return (name && *name) ? enqueue(new Message(name)) : false; }
00873 
00879     static bool dispatch(Message* msg);
00880 
00886     static bool dispatch(Message& msg);
00887 
00894     static bool dispatch(const char* name);
00895 
00901     inline void setHook(MessagePostHook* hook, bool remove = false)
00902         { m_dispatcher.setHook(hook,remove); }
00903 
00908     int usedPlugins();
00909 
00914     inline unsigned int messageCount()
00915         { return m_dispatcher.messageCount(); }
00916 
00921     inline unsigned int handlerCount()
00922         { return m_dispatcher.handlerCount(); }
00923 
00929     bool loadPluginDir(const String& relPath);
00930 
00931 protected:
00936     ~Engine();
00937 
00944     bool loadPlugin(const char* file, bool local = false);
00945 
00949     void loadPlugins();
00950 
00954     void initPlugins();
00955 
00956 private:
00957     Engine();
00958     ObjList m_libs;
00959     MessageDispatcher m_dispatcher;
00960     static Engine* s_self;
00961     static String s_cfgpath;
00962     static String s_cfgsuffix;
00963     static String s_modpath;
00964     static String s_modsuffix;
00965     static ObjList s_extramod;
00966     static int s_haltcode;
00967     static RunMode s_mode;
00968 };
00969 
00970 }; // namespace TelEngine
00971 
00972 #endif /* __YATENGINE_H */
00973 
00974 /* vi: set ts=8 sw=4 sts=4 noet: */

Generated on Sun Aug 12 19:02:55 2007 for Yate by  doxygen 1.5.2