Main Page | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members

yatephone.h

00001 /*
00002  * yatephone.h
00003  * This file is part of the YATE Project http://YATE.null.ro
00004  *
00005  * Drivers, channels and telephony 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 __YATEPHONE_H
00026 #define __YATEPHONE_H
00027 
00028 #ifndef __cplusplus
00029 #error C++ is required
00030 #endif
00031 
00032 #include <yatengine.h>
00033         
00037 namespace TelEngine {
00038 
00042 struct YATE_API ImageInfo {
00046     int width;
00047 
00051     int height;
00052 
00056     int depth;
00057 };
00058 
00062 struct YATE_API FormatInfo {
00066     const char* name;
00067 
00071     const char* type;
00072 
00076     int frameSize;
00077 
00081     int frameTime;
00082 
00086     int sampleRate;
00087 
00091     int numChannels;
00092 
00096     bool converter;
00097 
00103     int guessSamples(int len) const;
00104 
00109     int dataRate() const;
00110 
00114     inline FormatInfo()
00115         : name(0), type("audio"),
00116           frameSize(0), frameTime(0),
00117           sampleRate(8000), numChannels(1),
00118           converter(false)
00119         { }
00120 
00124     inline FormatInfo(const char* _name, int fsize = 0, int ftime = 10000,
00125         const char* _type = "audio", int srate = 8000, int nchan = 1, bool convert = false)
00126         : name(_name), type(_type),
00127           frameSize(fsize), frameTime(ftime),
00128           sampleRate(srate), numChannels(nchan),
00129           converter(convert)
00130         { }
00131 };
00132 
00133 class CallEndpoint;
00134 class Driver;
00135 
00140 struct YATE_API TranslatorCaps {
00142     const FormatInfo* src;
00144     const FormatInfo* dest;
00146     int cost;
00147 };
00148 
00153 class YATE_API FormatRepository
00154 {
00155 private:
00156     FormatRepository();
00157     FormatRepository& operator=(const FormatRepository&);
00158 public:
00164     static const FormatInfo* getFormat(const String& name);
00165 
00177     static const FormatInfo* addFormat(const String& name, int fsize, int ftime, const String& type = "audio", int srate = 8000, int nchan = 1);
00178 };
00179 
00184 class YATE_API DataFormat : public String
00185 {
00186 public:
00190     inline DataFormat()
00191         : m_parsed(0)
00192         { }
00193 
00198     inline DataFormat(const char* value)
00199         : String(value), m_parsed(0)
00200         { }
00201 
00206     inline DataFormat(const DataFormat& value)
00207         : String(value), m_parsed(value.getInfo())
00208         { }
00209 
00214     inline DataFormat(const String& value)
00215         : String(value), m_parsed(0)
00216         { }
00217 
00222     inline DataFormat(const String* value)
00223         : String(value), m_parsed(0)
00224         { }
00225 
00230     inline DataFormat(const FormatInfo* format)
00231         : String(format ? format->name : (const char*)0), m_parsed(format)
00232         { }
00233 
00237     inline DataFormat& operator=(const DataFormat& value)
00238         { String::operator=(value); return *this; }
00239 
00244     const FormatInfo* getInfo() const;
00245 
00251     inline int frameSize(int defValue = 0) const
00252         { return getInfo() ? getInfo()->frameSize : defValue; }
00253 
00259     inline int frameTime(int defValue = 0) const
00260         { return getInfo() ? getInfo()->frameTime : defValue; }
00261 
00268     inline int sampleRate(int defValue = 0) const
00269         { return getInfo() ? getInfo()->sampleRate : defValue; }
00270 
00276     inline int numChannels(int defValue = 1) const
00277         { return getInfo() ? getInfo()->numChannels : defValue; }
00278 
00279 protected:
00283     virtual void changed();
00284 
00285 private:
00286     mutable const FormatInfo* m_parsed;
00287 };
00288 
00292 class YATE_API DataNode : public RefObject
00293 {
00294 public:
00299     inline DataNode(const char* format = 0)
00300         : m_format(format), m_timestamp(0)
00301         { }
00302 
00308     virtual int costFormat(const DataFormat& format)
00309         { return -1; }
00310 
00316     virtual bool setFormat(const DataFormat& format)
00317         { return false; }
00318 
00323     inline const DataFormat& getFormat() const
00324         { return m_format; }
00325 
00330     inline unsigned long timeStamp() const
00331         { return m_timestamp; }
00332 
00333 protected:
00334     DataFormat m_format;
00335     unsigned long m_timestamp;
00336 };
00337 
00338 class DataSource;
00339 class DataTranslator;
00340 class TranslatorFactory;
00341 class ThreadedSourcePrivate;
00342 
00346 class YATE_API DataConsumer : public DataNode
00347 {
00348     friend class DataSource;
00349 
00350 public:
00355     inline DataConsumer(const char* format = "slin")
00356         : DataNode(format),
00357           m_source(0), m_override(0),
00358           m_regularTsDelta(0), m_overrideTsDelta(0), m_lastTsTime(0)
00359         { }
00360 
00364     virtual ~DataConsumer();
00365 
00371     virtual void* getObject(const String& name) const;
00372 
00378     virtual void Consume(const DataBlock& data, unsigned long tStamp) = 0;
00379 
00384     inline DataSource* getConnSource() const
00385         { return m_source; }
00386 
00391     inline DataSource* getOverSource() const
00392         { return m_override; }
00393 
00398     virtual DataSource* getTransSource() const
00399         { return 0; }
00400 
00401 protected:
00407     virtual bool synchronize(DataSource* source);
00408 
00409 private:
00410     void Consume(const DataBlock& data, unsigned long tStamp, DataSource* source);
00411     DataSource* m_source;
00412     DataSource* m_override;
00413     long m_regularTsDelta;
00414     long m_overrideTsDelta;
00415     u_int64_t m_lastTsTime;
00416 };
00417 
00421 class YATE_API DataSource : public DataNode
00422 {
00423     friend class DataTranslator;
00424 
00425 public:
00430     inline DataSource(const char* format = "slin")
00431         : DataNode(format), m_translator(0) { }
00432 
00436     virtual ~DataSource();
00437 
00443     virtual void* getObject(const String& name) const;
00444     
00450     void Forward(const DataBlock& data, unsigned long tStamp = (unsigned long)-1);
00451 
00458     bool attach(DataConsumer* consumer, bool override = false);
00459 
00465     bool detach(DataConsumer* consumer);
00466 
00470     void clear();
00471 
00476     inline Mutex* mutex()
00477         { return &m_mutex; }
00478 
00483     inline DataTranslator* getTranslator() const
00484         { return m_translator; }
00485 
00490     void synchronize(unsigned long tStamp);
00491 
00492 protected:
00493     DataTranslator* m_translator;
00494     ObjList m_consumers;
00495     Mutex m_mutex;
00496 private:
00497     inline void setTranslator(DataTranslator* translator)
00498         { m_translator = translator; }
00499     bool detachInternal(DataConsumer* consumer);
00500 };
00501 
00505 class YATE_API ThreadedSource : public DataSource
00506 {
00507     friend class ThreadedSourcePrivate;
00508 public:
00512     virtual ~ThreadedSource();
00513 
00520     bool start(const char* name = "ThreadedSource", Thread::Priority prio = Thread::Normal);
00521 
00525     void stop();
00526 
00531     Thread* thread() const;
00532 
00533 protected:
00538     inline ThreadedSource(const char* format = "slin")
00539         : DataSource(format), m_thread(0) { }
00540 
00544     virtual void run() = 0;
00545 
00549     virtual void cleanup();
00550 
00551 private:
00552     ThreadedSourcePrivate* m_thread;
00553 };
00554 
00560 class YATE_API DataTranslator : public DataConsumer
00561 {
00562     friend class TranslatorFactory;
00563 public:
00569     DataTranslator(const char* sFormat, const char* dFormat);
00570 
00577     DataTranslator(const char* sFormat, DataSource* source = 0);
00578 
00582     ~DataTranslator();
00583 
00589     virtual void* getObject(const String& name) const;
00590 
00595     virtual DataSource* getTransSource() const
00596         { return m_tsource; }
00597 
00602     DataTranslator* getFirstTranslator();
00603 
00608     const DataTranslator* getFirstTranslator() const;
00609 
00618     static ObjList* srcFormats(const DataFormat& dFormat = "slin", int maxCost = -1, unsigned int maxLen = 0, ObjList* lst = 0);
00619 
00628     static ObjList* destFormats(const DataFormat& sFormat = "slin", int maxCost = -1, unsigned int maxLen = 0, ObjList* lst = 0);
00629 
00636     static bool canConvert(const DataFormat& fmt1, const DataFormat& fmt2 = "slin");
00637 
00644     static int cost(const DataFormat& sFormat, const DataFormat& dFormat);
00645 
00652     static DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat);
00653 
00661     static bool attachChain(DataSource* source, DataConsumer* consumer, bool override = false);
00662 
00669     static bool detachChain(DataSource* source, DataConsumer* consumer);
00670 
00675     static void setMaxChain(unsigned int maxChain);
00676 
00677 protected:
00683     virtual bool synchronize(DataSource* source);
00684 
00689     static void install(TranslatorFactory* factory);
00690 
00695     static void uninstall(TranslatorFactory* factory);
00696 
00697 private:
00698     DataTranslator(); // No default constructor please
00699     static void compose();
00700     static void compose(TranslatorFactory* factory);
00701     static bool canConvert(const FormatInfo* fmt1, const FormatInfo* fmt2);
00702     DataSource* m_tsource;
00703     static Mutex s_mutex;
00704     static ObjList s_factories;
00705     static unsigned int s_maxChain;
00706 };
00707 
00713 class YATE_API TranslatorFactory : public GenObject
00714 {
00715 protected:
00719     inline TranslatorFactory()
00720         { DataTranslator::install(this); }
00721 
00722 public:
00726     virtual ~TranslatorFactory();
00727 
00732     virtual void removed(const TranslatorFactory* factory);
00733 
00740     virtual DataTranslator* create(const DataFormat& sFormat, const DataFormat& dFormat) = 0;
00741 
00746     virtual const TranslatorCaps* getCapabilities() const = 0;
00747 
00754     virtual bool converts(const DataFormat& sFormat, const DataFormat& dFormat) const;
00755 
00760     virtual unsigned int length() const;
00761 
00767     virtual bool intermediate(const FormatInfo* info) const;
00768 
00773     virtual const FormatInfo* intermediate() const;
00774 };
00775 
00781 class YATE_API DataEndpoint : public RefObject
00782 {
00783 public:
00784 
00788     DataEndpoint(CallEndpoint* call = 0, const char* name = "audio");
00789 
00793     ~DataEndpoint();
00794 
00800     virtual void* getObject(const String& name) const;
00801 
00806     virtual const String& toString() const;
00807 
00812     Mutex* mutex() const;
00813 
00818     static Mutex& commonMutex();
00819 
00825     bool connect(DataEndpoint* peer);
00826 
00831     bool disconnect();
00832 
00837     void setSource(DataSource* source = 0);
00838 
00843     inline DataSource* getSource() const
00844         { return m_source; }
00845 
00850     void setConsumer(DataConsumer* consumer = 0);
00851 
00856     inline DataConsumer* getConsumer() const
00857         { return m_consumer; }
00858 
00864     void setPeerRecord(DataConsumer* consumer = 0);
00865 
00870     inline DataConsumer* getPeerRecord() const
00871         { return m_peerRecord; }
00872 
00878     void setCallRecord(DataConsumer* consumer = 0);
00879 
00884     inline DataConsumer* getCallRecord() const
00885         { return m_callRecord; }
00886 
00891     inline DataEndpoint* getPeer() const
00892         { return m_peer; }
00893 
00898     inline CallEndpoint* getCall() const
00899         { return m_call; }
00900 
00905     inline const String& name() const
00906         { return m_name; }
00907 
00908 protected:
00914     virtual bool nativeConnect(DataEndpoint* peer)
00915         { return false; }
00916 
00917 private:
00918     String m_name;
00919     DataSource* m_source;
00920     DataConsumer* m_consumer;
00921     DataEndpoint* m_peer;
00922     CallEndpoint* m_call;
00923     DataConsumer* m_peerRecord;
00924     DataConsumer* m_callRecord;
00925 };
00926 
00931 class YATE_API CallEndpoint : public RefObject
00932 {
00933     friend class DataEndpoint;
00934 
00935 private:
00936     CallEndpoint* m_peer;
00937     String m_id;
00938 
00939 protected:
00940     ObjList m_data;
00941     Mutex* m_mutex;
00942 
00943 public:
00947     virtual ~CallEndpoint();
00948 
00954     virtual void* getObject(const String& name) const;
00955 
00960     virtual const String& toString() const
00961         { return m_id; }
00962 
00967     inline const String& id() const
00968         { return m_id; }
00969 
00974     inline CallEndpoint* getPeer() const
00975         { return m_peer; }
00976 
00981     inline const String& getPeerId() const
00982         { return m_peer ? m_peer->id() : String::empty(); }
00983 
00988     inline Mutex* mutex() const
00989         { return m_mutex; }
00990 
00995     static Mutex& commonMutex();
00996 
01004     bool connect(CallEndpoint* peer, const char* reason = 0, bool notify = true);
01005 
01012     inline bool disconnect(const char* reason = 0, bool notify = true)
01013         { return disconnect(false,reason,notify); }
01014 
01020     DataEndpoint* getEndpoint(const char* type = "audio") const;
01021 
01027     DataEndpoint* setEndpoint(const char* type = "audio");
01028 
01033     void clearEndpoint(const char* type = 0);
01034 
01040     void setSource(DataSource* source = 0, const char* type = "audio");
01041 
01047     DataSource* getSource(const char* type = "audio") const;
01048 
01054     void setConsumer(DataConsumer* consumer = 0, const char* type = "audio");
01055 
01061     DataConsumer* getConsumer(const char* type = "audio") const;
01062 
01063 protected:
01067     CallEndpoint(const char* id = 0);
01068 
01073     virtual void connected(const char* reason) { }
01074 
01080     virtual void disconnected(bool final, const char* reason) { }
01081 
01088     void setPeer(CallEndpoint* peer, const char* reason = 0, bool notify = true);
01089 
01094     virtual void setId(const char* newId);
01095 
01096 private:
01097     bool disconnect(bool final, const char* reason, bool notify);
01098 };
01099 
01104 class YATE_API Module : public Plugin, public Mutex, public MessageReceiver, public DebugEnabler
01105 {
01106 private:
01107     bool m_init;
01108     int m_relays;
01109     String m_name;
01110     String m_type;
01111     Regexp m_filter;
01112     u_int64_t m_changed;
01113     static unsigned int s_delay;
01114 
01115 public:
01121     virtual void* getObject(const String& name) const;
01122 
01127     inline const String& name() const
01128         { return m_name; }
01129 
01134     inline const String& type() const
01135         { return m_type; }
01136 
01141     void changed();
01142 
01147     inline static unsigned int updateDelay()
01148         { return s_delay; }
01149 
01154     inline static void updateDelay(unsigned int delay)
01155         { s_delay = delay; }
01156 
01161     inline bool filterInstalled() const
01162         { return !m_filter.null(); }
01163 
01169     bool filterDebug(const String& item) const;
01170 
01171 protected:
01175     enum {
01176         // Module messages
01177         Status     = 0x00000001,
01178         Timer      = 0x00000002,
01179         Level      = 0x00000004,
01180         Command    = 0x00000008,
01181         Help       = 0x00000010,
01182         Halt       = 0x00000020,
01183         Route      = 0x00000040,
01184         // Driver messages
01185         Execute    = 0x00000100,
01186         Drop       = 0x00000200,
01187         // Channel messages
01188         Locate     = 0x00000400,
01189         Masquerade = 0x00000800,
01190         Ringing    = 0x00001000,
01191         Answered   = 0x00002000,
01192         Tone       = 0x00004000,
01193         Text       = 0x00008000,
01194         Progress   = 0x00010000,
01195         Update     = 0x00020000,
01196         Transfer   = 0x00040000,
01197         // Last possible public ID
01198         PubLast    = 0x0fffffff,
01199         // Private messages base ID
01200         Private    = 0x10000000
01201     } RelayID;
01202 
01208     static const char* messageName(int id);
01209 
01215     Module(const char* name, const char* type = 0);
01216 
01220     virtual ~Module();
01221 
01225     virtual void initialize();
01226 
01230     void setup();
01231 
01238     bool installRelay(int id, unsigned priority = 100);
01239 
01246     bool installRelay(const char* name, unsigned priority = 100);
01247 
01254     virtual bool received(Message &msg, int id);
01255 
01260     virtual void genUpdate(Message& msg);
01261 
01266     virtual void msgTimer(Message& msg);
01267 
01272     virtual void msgStatus(Message& msg);
01273 
01278     virtual bool msgRoute(Message& msg);
01279 
01284     virtual void statusModule(String& str);
01285 
01290     virtual void statusParams(String& str);
01291 
01297     virtual bool setDebug(Message& msg, const String& target);
01298 
01299 private:
01300     Module(); // no default constructor please
01301     static TokenDict s_messages[];
01302     bool installRelay(const char* name, int id, unsigned priority);
01303 };
01304 
01309 class YATE_API Channel : public CallEndpoint, public DebugEnabler
01310 {
01311     friend class Driver;
01312     friend class Router;
01313 
01314 private:
01315     Driver* m_driver;
01316     bool m_outgoing;
01317     u_int64_t m_timeout;
01318     u_int64_t m_maxcall;
01319 
01320 protected:
01321     String m_status;
01322     String m_address;
01323     String m_targetid;
01324     String m_billid;
01325     bool m_answered;
01326 
01327 public:
01331     virtual ~Channel();
01332 
01338     virtual void* getObject(const String& name) const;
01339 
01345     virtual void complete(Message& msg, bool minimal = false) const;
01346 
01354     Message* message(const char* name, bool minimal = false, bool data = false);
01355 
01361     virtual bool msgProgress(Message& msg);
01362 
01368     virtual bool msgRinging(Message& msg);
01369 
01375     virtual bool msgAnswered(Message& msg);
01376 
01383     virtual bool msgTone(Message& msg, const char* tone);
01384 
01391     virtual bool msgText(Message& msg, const char* text);
01392 
01399     virtual bool msgDrop(Message& msg, const char* reason);
01400 
01406     virtual bool msgTransfer(Message& msg);
01407 
01413     virtual bool msgUpdate(Message& msg);
01414 
01419     virtual void msgStatus(Message& msg);
01420 
01426     virtual void checkTimers(Message& msg, const Time& tmr);
01427 
01434     virtual bool callPrerouted(Message& msg, bool handled);
01435 
01441     virtual bool callRouted(Message& msg);
01442 
01447     virtual void callAccept(Message& msg);
01448 
01455     virtual void callRejected(const char* error, const char* reason = 0, const Message* msg = 0);
01456 
01461     virtual bool setDebug(Message& msg);
01462 
01467     inline const String& status() const
01468         { return m_status; }
01469 
01474     inline const String& address() const
01475         { return m_address; }
01476 
01481     inline bool isOutgoing() const
01482         { return m_outgoing; }
01483 
01488     inline bool isIncoming() const
01489         { return !m_outgoing; }
01490 
01495     inline bool isAnswered() const
01496         { return m_answered; }
01497 
01502     const char* direction() const;
01503 
01508     inline Driver* driver() const
01509         { return m_driver; }
01510 
01515     inline u_int64_t timeout() const
01516         { return m_timeout; }
01517 
01522     inline void timeout(u_int64_t tout)
01523         { m_timeout = tout; }
01524 
01529     inline u_int64_t maxcall() const
01530         { return m_maxcall; }
01531 
01536     inline void maxcall(u_int64_t tout)
01537         { m_maxcall = tout; }
01538 
01543     inline void setMaxcall(const Message& msg)
01544         { setMaxcall(&msg); }
01545 
01550     void setMaxcall(const Message* msg);
01551 
01557     inline const String& targetid() const
01558         { return m_targetid; }
01559 
01565     inline const String& billid() const
01566         { return m_billid; }
01567 
01574     bool startRouter(Message* msg);
01575 
01580     static unsigned int allocId();
01581 
01586     void filterDebug(const String& item);
01587 
01588 protected:
01592     Channel(Driver* driver, const char* id = 0, bool outgoing = false);
01593 
01597     Channel(Driver& driver, const char* id = 0, bool outgoing = false);
01598 
01603     void cleanup();
01604 
01608     void dropChan();
01609 
01614     virtual void zeroRefs();
01615 
01620     virtual void connected(const char* reason);
01621 
01627     virtual void disconnected(bool final, const char* reason);
01628 
01633     virtual void setId(const char* newId);
01634 
01640     void status(const char* newstat);
01641 
01646     virtual void statusParams(String& str);
01647 
01652     inline void setOutgoing(bool outgoing = true)
01653         { m_outgoing = outgoing; }
01654 
01661     bool dtmfInband(const char* tone);
01662 
01663 private:
01664     void init();
01665     Channel(); // no default constructor please
01666 };
01667 
01672 class YATE_API Driver : public Module
01673 {
01674     friend class Router;
01675     friend class Channel;
01676 
01677 private:
01678     bool m_init;
01679     bool m_varchan;
01680     String m_prefix;
01681     ObjList m_chans;
01682     int m_routing;
01683     int m_routed;
01684     int m_total;
01685     unsigned int m_nextid;
01686     int m_timeout;
01687     int m_maxroute;
01688     int m_maxchans;
01689 
01690 public:
01696     virtual void* getObject(const String& name) const;
01697 
01702     inline const String& prefix() const
01703         { return m_prefix; }
01704 
01709     inline bool varchan() const
01710         { return m_varchan; }
01711 
01716     inline ObjList& channels()
01717         { return m_chans; }
01718 
01724     virtual Channel* find(const String& id) const;
01725 
01730     virtual bool isBusy() const;
01731 
01736     virtual void dropAll(Message &msg);
01737 
01743     virtual bool canAccept(bool routers = true);
01744 
01749     virtual bool canRoute();
01750 
01755     unsigned int nextid();
01756 
01761     inline unsigned int lastid() const
01762         { return m_nextid; }
01763 
01768     inline int timeout() const
01769         { return m_timeout; }
01770 
01775     inline int routing() const
01776         { return m_routing; }
01777 
01782     inline int routed() const
01783         { return m_routed; }
01784 
01789     inline int total() const
01790         { return m_total; }
01791 
01792 protected:
01798     Driver(const char* name, const char* type = 0);
01799 
01803     virtual void initialize();
01804 
01810     void setup(const char* prefix = 0, bool minimal = false);
01811 
01818     virtual bool received(Message &msg, int id);
01819 
01824     virtual void genUpdate(Message& msg);
01825 
01832     virtual bool msgExecute(Message& msg, String& dest) = 0;
01833 
01838     virtual void msgStatus(Message& msg);
01839 
01844     virtual void statusModule(String& str);
01845 
01850     virtual void statusParams(String& str);
01851 
01856     virtual void statusChannels(String& str);
01857 
01863     virtual bool setDebug(Message& msg, const String& target);
01864 
01868     virtual void loadLimits();
01869 
01874     inline void varchan(bool variable)
01875         { m_varchan = variable; }
01876 
01881     inline void timeout(int tout)
01882         { m_timeout = tout; }
01883 
01888     inline void maxRoute(int ncalls)
01889         { m_maxroute = ncalls; }
01890 
01895     inline void maxChans(int ncalls)
01896         { m_maxchans = ncalls; }
01897 
01898 private:
01899     Driver(); // no default constructor please
01900 };
01901 
01906 class YATE_API Router : public Thread
01907 {
01908 private:
01909     Driver* m_driver;
01910     String m_id;
01911     Message* m_msg;
01912 
01913 public:
01920     Router(Driver* driver, const char* id, Message* msg);
01921 
01925     virtual void run();
01926 
01931     virtual bool route();
01932 
01936     virtual void cleanup();
01937 
01938 protected:
01943     const String& id() const
01944         { return m_id; }
01945 };
01946 
01952 YATE_API bool isE164(const char* str);
01953 
01954 }; // namespace TelEngine
01955 
01956 #endif /* __YATEPHONE_H */
01957 
01958 /* vi: set ts=8 sw=4 sts=4 noet: */

Generated on Fri Jul 7 03:11:37 2006 for Yate by  doxygen 1.4.4