112        : name(0), type(
"audio"),
 
  113          frameSize(0), frameTime(0),
 
  114          sampleRate(8000), numChannels(1),
 
 
  121    inline explicit FormatInfo(
const char* _name, 
int fsize = 0, 
int ftime = 10000,
 
  122        const char* _type = 
"audio", 
int srate = 8000, 
int nchan = 1, 
bool convert = 
false)
 
  123        : name(_name), type(_type),
 
  124          frameSize(fsize), frameTime(ftime),
 
  125          sampleRate(srate), numChannels(nchan),
 
 
 
  205        : 
NamedList(value), m_parsed(value.getInfo())
 
 
  229        : 
NamedList(value ? value->c_str() : (const char*)0), m_parsed(0)
 
 
  237        : 
NamedList(format ? format->name : (const char*)0), m_parsed(format)
 
 
  258        { 
return getInfo() ? getInfo()->frameSize : defValue; }
 
 
  266        { 
return getInfo() ? getInfo()->frameTime : defValue; }
 
 
  275        { 
return getInfo() ? getInfo()->sampleRate : defValue; }
 
 
  283        { 
return getInfo() ? getInfo()->numChannels : defValue; }
 
 
 
  321        : m_format(format), m_timestamp(0)
 
 
  352        { 
return m_timestamp; }
 
 
  374        { 
return (
unsigned long)-1; }
 
 
  386    unsigned long m_timestamp;
 
 
  391class TranslatorFactory;
 
  392class ThreadedSourcePrivate;
 
  408          m_source(0), m_override(0),
 
  409          m_regularTsDelta(0), m_overrideTsDelta(0), m_lastTsTime(0)
 
 
  433    virtual unsigned long Consume(
const DataBlock& data, 
unsigned long tStamp, 
unsigned long flags) = 0;
 
  447        { 
return m_override; }
 
 
  465    unsigned long Consume(
const DataBlock& data, 
unsigned long tStamp,
 
  469    long m_regularTsDelta;
 
  470    long m_overrideTsDelta;
 
  471    u_int64_t m_lastTsTime;
 
 
  488          m_nextStamp(invalidStamp()), m_translator(0) { }
 
 
  523        unsigned long flags = 0);
 
  550        { 
return m_translator; }
 
 
  563        { 
return m_nextStamp; }
 
 
  566    unsigned long m_nextStamp;
 
  571            m_translator = translator;
 
  573    bool detachInternal(DataConsumer* consumer);
 
  574    DataTranslator* m_translator;
 
 
  583    friend class ThreadedSourcePrivate;
 
  640    bool looping(
bool runConsumers = 
false) 
const;
 
  643    ThreadedSourcePrivate* m_thread;
 
 
  687        { 
return m_tsource && m_tsource->valid(); }
 
 
  694        { 
return m_tsource; }
 
 
  801        { 
return m_tsource ? m_tsource->m_consumers.
skipNull() : 0; }
 
 
  824    static void compose();
 
  828    static Mutex s_mutex;
 
  830    static unsigned int s_maxChain;
 
 
  847        : m_name(name ? name : 
"?")
 
 
  907    virtual const char* 
name()
 const 
 
  915        { 
return m_counter; }
 
 
 
 1003        { 
return m_consumer; }
 
 
 1017        { 
return m_peerRecord; }
 
 
 1031        { 
return m_callRecord; }
 
 
 1094        { 
if (call == m_call) m_call = 0; }
 
 
 
 1133    const void* m_lastPeer;
 
 1230        { 
return disconnect(
false,reason,notify,params); }
 
 
 1239        { 
return disconnect(
false,reason,
true,¶ms); }
 
 
 1350    bool disconnect(
bool final, 
const char* reason, 
bool notify, 
const NamedList* params);
 
 
 1365    u_int64_t m_changed;
 
 1366    static unsigned int s_delay;
 
 1401        { s_delay = delay; }
 
 
 1408        { 
return !m_filter.
null(); }
 
 
 1436                ok = itemComplete(itemList,o->get()->
toString(),partWord) || ok;
 
 
 1451            for (; dict->
token; ++dict)
 
 1452                ok = itemComplete(itemList,dict->
token,partWord) || ok;
 
 
 1467            for (; dict->
token; ++dict)
 
 1468                ok = itemComplete(itemList,dict->
token,partWord) || ok;
 
 
 1478        Status     = 0x00000001,
 
 1481        Command    = 0x00000008,
 
 1487        Execute    = 0x00000100,
 
 1490        Locate     = 0x00000400,
 
 1491        Masquerade = 0x00000800,
 
 1492        Ringing    = 0x00001000,
 
 1493        Answered   = 0x00002000,
 
 1496        Progress   = 0x00010000,
 
 1497        Update     = 0x00020000,
 
 1498        Transfer   = 0x00040000,
 
 1499        Control    = 0x00080000,
 
 1501        MsgExecute = 0x00100000,
 
 1503        PubLast    = 0x00ffffff,
 
 1505        Private    = 0x01000000
 
 1521        { 
return lookup(name,s_messages); }
 
 
 1529    Module(
const char* name, 
const char* type = 0, 
bool earlyInit = 
false);
 
 1552        { 
return (
id & m_relays) != 0; }
 
 
 
 1714    u_int64_t m_timeout;
 
 1715    u_int64_t m_maxcall;
 
 1717    u_int64_t m_dtmfTime;
 
 1718    unsigned int m_toutAns;
 
 1719    unsigned int m_dtmfSeq;
 
 1787    inline Message* 
message(
const char* name, 
const NamedList& original, 
const char* params = 0, 
bool minimal = 
false, 
bool data = 
false)
 
 1788        { 
return message(name,&original,params,minimal,data); }
 
 
 1926            Lock lck(chanDataMutex());
 
 
 1955        { 
return m_address; }
 
 
 1962        { 
return m_outgoing; }
 
 
 1969        { 
return !m_outgoing; }
 
 
 1976        { 
return m_answered; }
 
 
 1989        { 
return m_driver; }
 
 
 1996        { 
return m_timeout; }
 
 
 2003        { m_timeout = tout; }
 
 
 2010        { 
return m_maxcall; }
 
 
 2017        { m_maxcall = tout; }
 
 
 2025        { setMaxcall(&msg,defTout); }
 
 
 2040        { 
return m_maxPDD; }
 
 
 2048        { m_maxPDD = tout; }
 
 
 2063        { 
return m_targetid; }
 
 
 2071        { 
return m_billid; }
 
 
 2104        { 
return m_parameters; }
 
 
 2112            const String& pref = in ? list[YSTRING(
"ichanparams-prefix")] : list[YSTRING(
"chanparams-prefix")];
 
 2115            Lock lck(paramMutex());
 
 
 2128            Lock lck(paramMutex());
 
 
 2219        { 
return m_status; }
 
 
 2232        { m_outgoing = outgoing; }
 
 
 2269        { 
return m_parameters; }
 
 
 2274    static Mutex s_chanDataMutex;
 
 2276    static inline Mutex* chanDataMutex()
 
 2277        { 
return &s_chanDataMutex; }
 
 
 2297    unsigned int m_nextid;
 
 2303    volatile bool m_doExpire;
 
 2318        { 
return m_prefix; }
 
 
 2325        { 
return m_varchan; }
 
 
 2377        { 
return m_nextid; }
 
 
 2384        { 
return m_timeout; }
 
 
 2391        { 
return m_routing; }
 
 
 2398        { 
return m_routed; }
 
 
 2412        { 
return m_chanCount; }
 
 
 2419        { 
return m_maxchans; }
 
 
 2427    Driver(
const char* name, 
const char* type = 0);
 
 2439    void setup(
const char* prefix = 0, 
bool minimal = 
false);
 
 2530        { m_varchan = variable; }
 
 
 2537        { m_timeout = tout; }
 
 
 2544        { m_maxroute = ncalls; }
 
 
 2551        { m_maxchans = ncalls; }
 
 
 2558        { m_dtmfDups = duplicates; }
 
 
 
 2654        { 
return m_inbParams; }
 
 
 2661        { 
return m_outParams; }
 
 
 2668        { 
return m_regParams; }
 
 
 2676        : m_mutex(mutex), m_inbParams(
""), m_outParams(
""), m_regParams(
"")
 
 
 
A class that holds just a block of raw data.
Definition yateclass.h:6074
A holder for a debug level.
Definition yateclass.h:329
Definition yateclass.h:1627
Ephemeral mutex, semaphore or rw-lock locking object.
Definition yateclass.h:10000
Mutex support.
Definition yateclass.h:9403
Atomic counter with name.
Definition yateclass.h:5428
A named string container class.
Definition yateclass.h:7690
NamedList & operator=(const NamedList &value)
NamedList & setParam(NamedString *param)
NamedList & addParam(NamedString *param)
NamedList & copySubParams(const NamedList &original, const String &prefix, bool skipPrefix=true, bool replace=false)
NamedList & copyParams(bool replace, const NamedList &original, bool copyUserData=false)
A named string class.
Definition yateclass.h:5304
An object list class.
Definition yateclass.h:2032
ObjList * skipNull() const
Definition yateclass.h:1752
A regexp matching class.
Definition yateclass.h:5094
A C-style string handling class.
Definition yateclass.h:3055
const char * c_str() const
Definition yateclass.h:3160
bool null() const
Definition yateclass.h:3189
virtual const String & toString() const
static const String & empty()
Settings for an account handling calls.
Definition yatephone.h:2615
void setInboundParams(NamedList ¶ms)
void setRegisterParams(NamedList ¶ms)
void pickAccountParams(const NamedList ¶ms)
const NamedList & inboundParams() const
Definition yatephone.h:2653
CallAccount(Mutex *mutex)
Definition yatephone.h:2675
const NamedList & outboundParams() const
Definition yatephone.h:2660
const NamedList & registerParams() const
Definition yatephone.h:2667
void setOutboundParams(NamedList ¶ms)
An abstract call endpoint.
Definition yatephone.h:1128
void setConsumer(DataConsumer *consumer=0, const String &type=CallEndpoint::audioType())
virtual void * getObject(const String &name) const
DataEndpoint * getEndpoint(const String &type=CallEndpoint::audioType()) const
DataSource * getSource(const String &type=CallEndpoint::audioType()) const
bool clearData(DataNode *node, const String &type=CallEndpoint::audioType())
bool getPeerId(String &id) const
virtual void connected(const char *reason)
Definition yatephone.h:1313
const String & id() const
Definition yatephone.h:1165
Mutex * mutex() const
Definition yatephone.h:1204
bool connect(CallEndpoint *peer, const char *reason=0, bool notify=true)
void setEndpoint(DataEndpoint *endPoint)
CallEndpoint(const char *id=0)
void clearEndpoint(const String &type=String::empty())
void setSource(DataSource *source=0, const String &type=CallEndpoint::audioType())
static const String & audioType()
virtual const String & toString() const
Definition yatephone.h:1158
bool disconnect(const char *reason, const NamedList ¶ms)
Definition yatephone.h:1238
DataConsumer * getConsumer(const String &type=CallEndpoint::audioType()) const
CallEndpoint * getPeer() const
Definition yatephone.h:1172
virtual void setDisconnect(const NamedList *params)
Definition yatephone.h:1326
virtual void setId(const char *newId)
DataEndpoint * setEndpoint(const String &type=CallEndpoint::audioType())
bool disconnect(const char *reason=0, bool notify=true, const NamedList *params=0)
Definition yatephone.h:1229
static Mutex & commonMutex()
bool getLastPeerId(String &id) const
virtual void disconnected(bool final, const char *reason)
Definition yatephone.h:1320
void setPeer(CallEndpoint *peer, const char *reason=0, bool notify=true, const NamedList *params=0)
An abstract communication channel.
Definition yatephone.h:1705
virtual bool msgRinging(Message &msg)
virtual void statusParams(String &str)
virtual bool msgMasquerade(Message &msg)
virtual void * getObject(const String &name) const
void setMaxPDD(const Message &msg)
virtual bool msgTransfer(Message &msg)
NamedList & parameters()
Definition yatephone.h:2268
void setMaxcall(const Message *msg, int defTout=-1)
virtual bool callRouted(Message &msg)
bool dtmfInband(const char *tone)
virtual bool msgProgress(Message &msg)
virtual void callConnect(Message &msg)
void putStatus(NamedList &list, const char *param="status", bool append=true) const
Definition yatephone.h:1941
Message * message(const char *name, bool minimal=false, bool data=false)
void timeout(u_int64_t tout)
Definition yatephone.h:2002
u_int64_t timeout() const
Definition yatephone.h:1995
void setMaxcall(const Message &msg, int defTout=-1)
Definition yatephone.h:2024
static unsigned int allocId()
bool dtmfEnqueue(Message *msg)
Message * message(const char *name, const NamedList &original, const char *params=0, bool minimal=false, bool data=false)
Definition yatephone.h:1787
const char * direction() const
virtual bool setDebug(Message &msg)
virtual bool msgDrop(Message &msg, const char *reason)
virtual void connected(const char *reason)
void setOutgoing(bool outgoing=true)
Definition yatephone.h:2231
String & getStatus(String &buf, bool append=true) const
Definition yatephone.h:1925
void maxPDD(u_int64_t tout)
Definition yatephone.h:2047
virtual bool msgAnswered(Message &msg)
virtual bool msgTone(Message &msg, const char *tone)
virtual void endDisconnect(const Message &msg, bool handled)
virtual Message * getDisconnect(const char *reason)
u_int64_t maxcall() const
Definition yatephone.h:2009
bool dtmfSequence(Message &msg)
Driver * driver() const
Definition yatephone.h:1988
const String & getStatus() const
Definition yatephone.h:2218
virtual void dispatched(const Message &msg, bool handled)
Channel(Driver &driver, const char *id=0, bool outgoing=false)
bool isIncoming() const
Definition yatephone.h:1968
bool isOutgoing() const
Definition yatephone.h:1961
void maxcall(u_int64_t tout)
Definition yatephone.h:2016
bool isAnswered() const
Definition yatephone.h:1975
virtual void callRejected(const char *error, const char *reason=0, const Message *msg=0)
Message * message(const char *name, const NamedList *original, const char *params=0, bool minimal=false, bool data=false)
bool startRouter(Message *msg)
virtual void msgStatus(Message &msg)
virtual bool callPrerouted(Message &msg, bool handled)
bool toneDetect(const char *sniffer=0)
virtual bool msgControl(Message &msg)
const String & billid() const
Definition yatephone.h:2070
virtual void callAccept(Message &msg)
virtual void setDisconnect(const NamedList *params)
void filterDebug(const String &item)
virtual void setId(const char *newId)
virtual bool msgUpdate(Message &msg)
const String & address() const
Definition yatephone.h:1954
virtual void complete(Message &msg, bool minimal=false) const
u_int64_t maxPDD() const
Definition yatephone.h:2039
void copyChanParams(NamedList &list) const
Definition yatephone.h:2125
Channel(Driver *driver, const char *id=0, bool outgoing=false)
void setChanParams(const NamedList &list, bool in=false)
Definition yatephone.h:2111
const NamedList & parameters() const
Definition yatephone.h:2103
virtual bool msgText(Message &msg, const char *text)
const String & targetid() const
Definition yatephone.h:2062
static Mutex & paramMutex()
virtual void disconnected(bool final, const char *reason)
void status(const char *newstat)
virtual void checkTimers(Message &msg, const Time &tmr)
Definition yatephone.h:398
virtual void * getObject(const String &name) const
DataConsumer(const char *format="slin")
Definition yatephone.h:406
DataSource * getOverSource() const
Definition yatephone.h:446
virtual DataSource * getTransSource() const
Definition yatephone.h:453
virtual bool synchronize(DataSource *source)
DataSource * getConnSource() const
Definition yatephone.h:439
virtual unsigned long Consume(const DataBlock &data, unsigned long tStamp, unsigned long flags)=0
A data transfer endpoint capable of sending and/or receiving data.
Definition yatephone.h:928
bool delSniffer(DataConsumer *sniffer)
virtual void * getObject(const String &name) const
bool addSniffer(DataConsumer *sniffer)
void clearCall(const CallEndpoint *call)
Definition yatephone.h:1093
void setConsumer(DataConsumer *consumer=0)
DataConsumer * getCallRecord() const
Definition yatephone.h:1030
virtual bool nativeConnect(DataEndpoint *peer)
Definition yatephone.h:1109
bool clearData(DataNode *node)
void setCallRecord(DataConsumer *consumer=0)
DataConsumer * getConsumer() const
Definition yatephone.h:1002
DataEndpoint * getPeer() const
Definition yatephone.h:1071
DataConsumer * getPeerRecord() const
Definition yatephone.h:1016
DataSource * getSource() const
Definition yatephone.h:989
CallEndpoint * getCall() const
Definition yatephone.h:1078
virtual const String & toString() const
void setSource(DataSource *source=0)
DataConsumer * getSniffer(const String &name, bool ref=false)
DataEndpoint(CallEndpoint *call=0, const char *name="audio")
const String & name() const
Definition yatephone.h:1085
void setPeerRecord(DataConsumer *consumer=0)
static Mutex & commonMutex()
virtual bool control(NamedList ¶ms)
bool connect(DataEndpoint *peer)
Definition yatephone.h:299
virtual void attached(bool added)
Definition yatephone.h:381
virtual bool valid() const
Definition yatephone.h:358
unsigned long timeStamp() const
Definition yatephone.h:351
virtual int costFormat(const DataFormat &format)
Definition yatephone.h:329
DataNode(const char *format=0)
Definition yatephone.h:320
static unsigned long invalidStamp()
Definition yatephone.h:373
virtual bool setFormat(const DataFormat &format)
Definition yatephone.h:337
DataFlags
Definition yatephone.h:306
const DataFormat & getFormat() const
Definition yatephone.h:344
virtual bool control(NamedList ¶ms)
Definition yatephone.h:366
Definition yatephone.h:478
void synchronize(unsigned long tStamp)
virtual void * getObject(const String &name) const
unsigned long Forward(const DataBlock &data, unsigned long tStamp=invalidStamp(), unsigned long flags=0)
unsigned long nextStamp() const
Definition yatephone.h:562
virtual bool valid() const
bool attach(DataConsumer *consumer, bool override=false)
bool detach(DataConsumer *consumer)
DataTranslator * getTranslator() const
Definition yatephone.h:549
DataSource(const char *format="slin")
Definition yatephone.h:486
virtual bool control(NamedList ¶ms)
An unidirectional data translator (codec)
Definition yatephone.h:652
static ObjList * allFormats(const String &formats, bool existing=true, bool sameRate=true, bool sameChans=true)
static bool attachChain(DataSource *source, DataConsumer *consumer, bool override=false)
virtual void * getObject(const String &name) const
static ObjList * destFormats(const DataFormat &sFormat="slin", int maxCost=-1, unsigned int maxLen=0, ObjList *lst=0)
static bool canConvert(const DataFormat &fmt1, const DataFormat &fmt2="slin")
DataTranslator(const char *sFormat, const char *dFormat)
virtual bool valid() const
Definition yatephone.h:686
const DataTranslator * getFirstTranslator() const
static void uninstall(TranslatorFactory *factory)
static ObjList * allFormats(const ObjList *formats, bool existing=true, bool sameRate=true, bool sameChans=true)
ObjList * getConsumers() const
Definition yatephone.h:800
static ObjList * srcFormats(const DataFormat &dFormat="slin", int maxCost=-1, unsigned int maxLen=0, ObjList *lst=0)
static void install(TranslatorFactory *factory)
static DataTranslator * create(const DataFormat &sFormat, const DataFormat &dFormat)
virtual DataSource * getTransSource() const
Definition yatephone.h:693
static void setMaxChain(unsigned int maxChain)
static int cost(const DataFormat &sFormat, const DataFormat &dFormat)
DataTranslator * getFirstTranslator()
virtual bool synchronize(DataSource *source)
DataTranslator(const char *sFormat, DataSource *source=0)
static bool detachChain(DataSource *source, DataConsumer *consumer)
A Channel driver module.
Definition yatephone.h:2285
void setup(const char *prefix=0, bool minimal=false)
virtual bool msgExecute(Message &msg, String &dest)=0
Driver(const char *name, const char *type=0)
virtual void statusParams(String &str)
void timeout(int tout)
Definition yatephone.h:2536
virtual bool setDebug(Message &msg, const String &target)
virtual void statusModule(String &str)
virtual void * getObject(const String &name) const
int chanCount() const
Definition yatephone.h:2411
virtual void dropAll(Message &msg)
virtual void genUpdate(Message &msg)
virtual void statusDetail(String &str)
int timeout() const
Definition yatephone.h:2383
bool varchan() const
Definition yatephone.h:2324
virtual void loadLimits()
virtual void initialize()
void maxRoute(int ncalls)
Definition yatephone.h:2543
unsigned int lastid() const
Definition yatephone.h:2376
const String & prefix() const
Definition yatephone.h:2317
virtual bool received(Message &msg, int id)
int maxChans() const
Definition yatephone.h:2418
int routing() const
Definition yatephone.h:2390
int routed() const
Definition yatephone.h:2397
virtual bool hasLine(const String &line) const
ObjList & channels()
Definition yatephone.h:2331
virtual bool canAccept(bool routers=true)
void varchan(bool variable)
Definition yatephone.h:2529
void dtmfDups(bool duplicates)
Definition yatephone.h:2557
virtual bool canStopCall() const
Definition yatephone.h:2522
virtual bool msgRoute(Message &msg)
virtual bool isBusy() const
void maxChans(int ncalls)
Definition yatephone.h:2550
virtual Channel * find(const String &id) const
virtual bool commandComplete(Message &msg, const String &partLine, const String &partWord)
int total() const
Definition yatephone.h:2404
Post-dispatching message hook.
Definition yatengine.h:875
A multiple message receiver.
Definition yatengine.h:806
A message handler relay.
Definition yatengine.h:822
A message container class.
Definition yatengine.h:380
A Plugin that implements a module.
Definition yatephone.h:1358
virtual void statusParams(String &str)
virtual void msgTimer(Message &msg)
virtual bool setDebug(Message &msg, const String &target)
bool filterInstalled() const
Definition yatephone.h:1407
virtual void statusModule(String &str)
static const char * messageName(int id)
virtual void * getObject(const String &name) const
static bool itemComplete(String &itemList, const TokenDict64 *dict, const String &partWord)
Definition yatephone.h:1463
bool filterDebug(const String &item) const
virtual bool commandExecute(String &retVal, const String &line)
bool uninstallRelay(int id, bool delRelay=true)
bool relayInstalled(int id) const
Definition yatephone.h:1551
bool installRelay(int id, const char *name, unsigned priority=100, NamedString *filter=0)
virtual void genUpdate(Message &msg)
static bool itemComplete(String &itemList, const TokenDict *dict, const String &partWord)
Definition yatephone.h:1447
virtual void statusDetail(String &str)
bool installRelay(MessageRelay *relay)
static bool itemComplete(String &itemList, const ObjList &list, const String &partWord)
Definition yatephone.h:1433
virtual void initialize()
static bool itemComplete(String &itemList, const String &item, const String &partWord)
bool uninstallRelay(MessageRelay *relay, bool delRelay=true)
virtual bool received(Message &msg, int id)
static unsigned int updateDelay()
Definition yatephone.h:1393
static int relayId(const char *name)
Definition yatephone.h:1520
const String & type() const
Definition yatephone.h:1380
enum TelEngine::Module::@0 RelayID
virtual void msgStatus(Message &msg)
Module(const char *name, const char *type=0, bool earlyInit=false)
bool installRelay(int id, unsigned priority=100, NamedString *filter=0)
bool installRelay(const char *name, unsigned priority=100, NamedString *filter=0)
virtual bool msgRoute(Message &msg)
virtual bool msgCommand(Message &msg)
virtual bool commandComplete(Message &msg, const String &partLine, const String &partWord)
static void updateDelay(unsigned int delay)
Definition yatephone.h:1400
Plugin support.
Definition yatengine.h:1279
bool earlyInit() const
Definition yatengine.h:1339
const String & name() const
Definition yatengine.h:1325
Call routing thread.
Definition yatephone.h:2569
const String & id() const
Definition yatephone.h:2606
Router(Driver *driver, const char *id, Message *msg)
Data source with own thread.
Definition yatephone.h:582
bool start(const char *name="ThreadedSource", Thread::Priority prio=Thread::Normal)
bool looping(bool runConsumers=false) const
ThreadedSource(const char *format="slin")
Definition yatephone.h:620
An unidirectional data translator (codec)
Definition yatephone.h:839
virtual const TranslatorCaps * getCapabilities() const =0
virtual const char * name() const
Definition yatephone.h:907
TranslatorFactory(const char *name=0)
Definition yatephone.h:846
virtual const FormatInfo * intermediate() const
virtual bool converts(const DataFormat &sFormat, const DataFormat &dFormat) const
virtual ~TranslatorFactory()
virtual unsigned int length() const
virtual void removed(const TranslatorFactory *factory)
virtual DataTranslator * create(const DataFormat &sFormat, const DataFormat &dFormat)=0
virtual bool intermediate(const FormatInfo *info) const
NamedCounter * objectsCounter() const
Definition yatephone.h:914
Thread support class.
Definition yateclass.h:10192
Priority
Definition yateclass.h:10202
static NamedCounter * getCurrentObjCounter(bool always=false)
A time holding class.
Definition yateclass.h:5764
bool isE164(const char *str)
Definition yatephone.h:39
int width
Definition yatephone.h:43
int depth
Definition yatephone.h:53
int height
Definition yatephone.h:48
Definition yatephone.h:138
const FormatInfo * dest
Definition yatephone.h:142
int cost
Definition yatephone.h:144
const FormatInfo * src
Definition yatephone.h:140
Definition yateclass.h:908
const char * token
Definition yateclass.h:912
Definition yateclass.h:891
const char * token
Definition yateclass.h:895