arts Library API Documentation

artskde.h

00001 /* this file was generated by the MCOP idl compiler - DO NOT EDIT */
00002 
00003 #ifndef ARTSKDE_H
00004 #define ARTSKDE_H
00005 
00006 #include "common.h"
00007 
00008 // includes of other idl definitions
00009 #include "kmedia2.h"
00010 #include "artsflow.h"
00011 
00012 namespace Arts {
00013 class KFloatWatchProxy;
00014 class KIOInputStream;
00015 class KDataRequest;
00016 class KIOTestSlow;
00017 
00018 class KFloatWatchProxy_base : virtual public Arts::Object_base {
00019 public:
00020     static unsigned long _IID; // interface ID
00021 
00022     static KFloatWatchProxy_base *_create(const std::string& subClass = "Arts::KFloatWatchProxy");
00023     static KFloatWatchProxy_base *_fromString(const std::string& objectref);
00024     static KFloatWatchProxy_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
00025 
00026     static KFloatWatchProxy_base *_fromDynamicCast(const Arts::Object& object);
00027     inline KFloatWatchProxy_base *_copy() {
00028         assert(_refCnt > 0);
00029         _refCnt++;
00030         return this;
00031     }
00032 
00033     virtual std::vector<std::string> _defaultPortsIn() const;
00034     virtual std::vector<std::string> _defaultPortsOut() const;
00035 
00036     void *_cast(unsigned long iid);
00037 
00038     virtual float value() = 0;
00039     virtual void value(float newValue) = 0;
00040 };
00041 
00042 class KFloatWatchProxy_stub : virtual public KFloatWatchProxy_base, virtual public Arts::Object_stub {
00043 protected:
00044     KFloatWatchProxy_stub();
00045 
00046 public:
00047     KFloatWatchProxy_stub(Arts::Connection *connection, long objectID);
00048 
00049     float value();
00050     void value(float newValue);
00051 };
00052 
00053 class KFloatWatchProxy_skel : virtual public KFloatWatchProxy_base, virtual public Arts::Object_skel {
00054 protected:
00055     // emitters for change notifications
00056     inline void value_changed(float newValue) {
00057         _emit_changed("value_changed",newValue);
00058     }
00059 
00060 public:
00061     KFloatWatchProxy_skel();
00062 
00063     static std::string _interfaceNameSkel();
00064     std::string _interfaceName();
00065     bool _isCompatibleWith(const std::string& interfacename);
00066     void _buildMethodTable();
00067     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
00068 };
00069 
00070 }
00071 #include "reference.h"
00072 namespace Arts {
00073 class KFloatWatchProxy : public Arts::Object {
00074 private:
00075     static Arts::Object_base* _Creator();
00076     KFloatWatchProxy_base *_cache;
00077     inline KFloatWatchProxy_base *_method_call() {
00078         _pool->checkcreate();
00079         if(_pool->base) {
00080             _cache=(KFloatWatchProxy_base *)_pool->base->_cast(KFloatWatchProxy_base::_IID);
00081             assert(_cache);
00082         }
00083         return _cache;
00084     }
00085 
00086 protected:
00087     inline KFloatWatchProxy(KFloatWatchProxy_base* b) : Arts::Object(b), _cache(0) {}
00088 
00089 
00090 public:
00091     typedef KFloatWatchProxy_base _base_class;
00092 
00093     inline KFloatWatchProxy() : Arts::Object(_Creator), _cache(0) {}
00094     inline KFloatWatchProxy(const Arts::SubClass& s) :
00095         Arts::Object(KFloatWatchProxy_base::_create(s.string())), _cache(0) {}
00096     inline KFloatWatchProxy(const Arts::Reference &r) :
00097         Arts::Object(r.isString()?(KFloatWatchProxy_base::_fromString(r.string())):(KFloatWatchProxy_base::_fromReference(r.reference(),true))), _cache(0) {}
00098     inline KFloatWatchProxy(const Arts::DynamicCast& c) : Arts::Object(KFloatWatchProxy_base::_fromDynamicCast(c.object())), _cache(0) {}
00099     inline KFloatWatchProxy(const KFloatWatchProxy& target) : Arts::Object(target._pool), _cache(target._cache) {}
00100     inline KFloatWatchProxy(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
00101     inline static KFloatWatchProxy null() {return KFloatWatchProxy((KFloatWatchProxy_base*)0);}
00102     inline static KFloatWatchProxy _from_base(KFloatWatchProxy_base* b) {return KFloatWatchProxy(b);}
00103     inline KFloatWatchProxy& operator=(const KFloatWatchProxy& target) {
00104         if (_pool == target._pool) return *this;
00105         _pool->Dec();
00106         _pool = target._pool;
00107         _cache = target._cache;
00108         _pool->Inc();
00109         return *this;
00110     }
00111     inline KFloatWatchProxy_base* _base() {return _cache?_cache:_method_call();}
00112 
00113     inline float value();
00114     inline void value(float _newValue);
00115 };
00116 
00117 class KIOInputStream_base : virtual public Arts::InputStream_base {
00118 public:
00119     static unsigned long _IID; // interface ID
00120 
00121     static KIOInputStream_base *_create(const std::string& subClass = "Arts::KIOInputStream");
00122     static KIOInputStream_base *_fromString(const std::string& objectref);
00123     static KIOInputStream_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
00124 
00125     static KIOInputStream_base *_fromDynamicCast(const Arts::Object& object);
00126     inline KIOInputStream_base *_copy() {
00127         assert(_refCnt > 0);
00128         _refCnt++;
00129         return this;
00130     }
00131 
00132     virtual std::vector<std::string> _defaultPortsIn() const;
00133     virtual std::vector<std::string> _defaultPortsOut() const;
00134 
00135     void *_cast(unsigned long iid);
00136 
00137     virtual long bufferPackets() = 0;
00138     virtual void bufferPackets(long newValue) = 0;
00139     virtual bool openURL(const std::string& url) = 0;
00140     virtual long packetSize() = 0;
00141 };
00142 
00143 class KIOInputStream_stub : virtual public KIOInputStream_base, virtual public Arts::InputStream_stub {
00144 protected:
00145     KIOInputStream_stub();
00146 
00147 public:
00148     KIOInputStream_stub(Arts::Connection *connection, long objectID);
00149 
00150     long bufferPackets();
00151     void bufferPackets(long newValue);
00152     bool openURL(const std::string& url);
00153     long packetSize();
00154 };
00155 
00156 class KIOInputStream_skel : virtual public KIOInputStream_base, virtual public Arts::InputStream_skel {
00157 protected:
00158     // emitters for change notifications
00159     inline void bufferPackets_changed(long newValue) {
00160         _emit_changed("bufferPackets_changed",newValue);
00161     }
00162 
00163 public:
00164     KIOInputStream_skel();
00165 
00166     static std::string _interfaceNameSkel();
00167     std::string _interfaceName();
00168     bool _isCompatibleWith(const std::string& interfacename);
00169     void _buildMethodTable();
00170     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
00171 };
00172 
00173 }
00174 #include "reference.h"
00175 namespace Arts {
00176 class KIOInputStream : public Arts::Object {
00177 private:
00178     static Arts::Object_base* _Creator();
00179     KIOInputStream_base *_cache;
00180     inline KIOInputStream_base *_method_call() {
00181         _pool->checkcreate();
00182         if(_pool->base) {
00183             _cache=(KIOInputStream_base *)_pool->base->_cast(KIOInputStream_base::_IID);
00184             assert(_cache);
00185         }
00186         return _cache;
00187     }
00188 
00189 protected:
00190     inline KIOInputStream(KIOInputStream_base* b) : Arts::Object(b), _cache(0) {}
00191 
00192 
00193 public:
00194     typedef KIOInputStream_base _base_class;
00195 
00196     inline KIOInputStream() : Arts::Object(_Creator), _cache(0) {}
00197     inline KIOInputStream(const Arts::SubClass& s) :
00198         Arts::Object(KIOInputStream_base::_create(s.string())), _cache(0) {}
00199     inline KIOInputStream(const Arts::Reference &r) :
00200         Arts::Object(r.isString()?(KIOInputStream_base::_fromString(r.string())):(KIOInputStream_base::_fromReference(r.reference(),true))), _cache(0) {}
00201     inline KIOInputStream(const Arts::DynamicCast& c) : Arts::Object(KIOInputStream_base::_fromDynamicCast(c.object())), _cache(0) {}
00202     inline KIOInputStream(const KIOInputStream& target) : Arts::Object(target._pool), _cache(target._cache) {}
00203     inline KIOInputStream(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
00204     inline static KIOInputStream null() {return KIOInputStream((KIOInputStream_base*)0);}
00205     inline static KIOInputStream _from_base(KIOInputStream_base* b) {return KIOInputStream(b);}
00206     inline KIOInputStream& operator=(const KIOInputStream& target) {
00207         if (_pool == target._pool) return *this;
00208         _pool->Dec();
00209         _pool = target._pool;
00210         _cache = target._cache;
00211         _pool->Inc();
00212         return *this;
00213     }
00214     inline operator Arts::InputStream() const { return Arts::InputStream(*_pool); }
00215     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
00216     inline KIOInputStream_base* _base() {return _cache?_cache:_method_call();}
00217 
00218     inline bool eof();
00219     inline long size();
00220     inline bool seekOk();
00221     inline long seek(long position);
00222     inline Arts::AutoSuspendState autoSuspend();
00223     inline void start();
00224     inline void stop();
00225     inline void streamInit();
00226     inline void streamStart();
00227     inline void streamEnd();
00228     inline long bufferPackets();
00229     inline void bufferPackets(long _newValue);
00230     inline bool openURL(const std::string& url);
00231     inline long packetSize();
00232 };
00233 
00234 class KDataRequest_base : virtual public Arts::SynthModule_base {
00235 public:
00236     static unsigned long _IID; // interface ID
00237 
00238     static KDataRequest_base *_create(const std::string& subClass = "Arts::KDataRequest");
00239     static KDataRequest_base *_fromString(const std::string& objectref);
00240     static KDataRequest_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
00241 
00242     static KDataRequest_base *_fromDynamicCast(const Arts::Object& object);
00243     inline KDataRequest_base *_copy() {
00244         assert(_refCnt > 0);
00245         _refCnt++;
00246         return this;
00247     }
00248 
00249     virtual std::vector<std::string> _defaultPortsIn() const;
00250     virtual std::vector<std::string> _defaultPortsOut() const;
00251 
00252     void *_cast(unsigned long iid);
00253 
00254     virtual void goOn() = 0;
00255 };
00256 
00257 class KDataRequest_stub : virtual public KDataRequest_base, virtual public Arts::SynthModule_stub {
00258 protected:
00259     KDataRequest_stub();
00260 
00261 public:
00262     KDataRequest_stub(Arts::Connection *connection, long objectID);
00263 
00264     void goOn();
00265 };
00266 
00267 class KDataRequest_skel : virtual public KDataRequest_base, virtual public Arts::SynthModule_skel {
00268 protected:
00269     // variables for streams
00270     float *left;                              // incoming stream
00271     float *right;                             // incoming stream
00272 
00273 public:
00274     KDataRequest_skel();
00275 
00276     static std::string _interfaceNameSkel();
00277     std::string _interfaceName();
00278     bool _isCompatibleWith(const std::string& interfacename);
00279     void _buildMethodTable();
00280     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
00281 };
00282 
00283 }
00284 #include "reference.h"
00285 namespace Arts {
00286 class KDataRequest : public Arts::Object {
00287 private:
00288     static Arts::Object_base* _Creator();
00289     KDataRequest_base *_cache;
00290     inline KDataRequest_base *_method_call() {
00291         _pool->checkcreate();
00292         if(_pool->base) {
00293             _cache=(KDataRequest_base *)_pool->base->_cast(KDataRequest_base::_IID);
00294             assert(_cache);
00295         }
00296         return _cache;
00297     }
00298 
00299 protected:
00300     inline KDataRequest(KDataRequest_base* b) : Arts::Object(b), _cache(0) {}
00301 
00302 
00303 public:
00304     typedef KDataRequest_base _base_class;
00305 
00306     inline KDataRequest() : Arts::Object(_Creator), _cache(0) {}
00307     inline KDataRequest(const Arts::SubClass& s) :
00308         Arts::Object(KDataRequest_base::_create(s.string())), _cache(0) {}
00309     inline KDataRequest(const Arts::Reference &r) :
00310         Arts::Object(r.isString()?(KDataRequest_base::_fromString(r.string())):(KDataRequest_base::_fromReference(r.reference(),true))), _cache(0) {}
00311     inline KDataRequest(const Arts::DynamicCast& c) : Arts::Object(KDataRequest_base::_fromDynamicCast(c.object())), _cache(0) {}
00312     inline KDataRequest(const KDataRequest& target) : Arts::Object(target._pool), _cache(target._cache) {}
00313     inline KDataRequest(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
00314     inline static KDataRequest null() {return KDataRequest((KDataRequest_base*)0);}
00315     inline static KDataRequest _from_base(KDataRequest_base* b) {return KDataRequest(b);}
00316     inline KDataRequest& operator=(const KDataRequest& target) {
00317         if (_pool == target._pool) return *this;
00318         _pool->Dec();
00319         _pool = target._pool;
00320         _cache = target._cache;
00321         _pool->Inc();
00322         return *this;
00323     }
00324     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
00325     inline KDataRequest_base* _base() {return _cache?_cache:_method_call();}
00326 
00327     inline Arts::AutoSuspendState autoSuspend();
00328     inline void start();
00329     inline void stop();
00330     inline void streamInit();
00331     inline void streamStart();
00332     inline void streamEnd();
00333     inline void goOn();
00334 };
00335 
00336 class KIOTestSlow_base : virtual public Arts::SynthModule_base {
00337 public:
00338     static unsigned long _IID; // interface ID
00339 
00340     static KIOTestSlow_base *_create(const std::string& subClass = "Arts::KIOTestSlow");
00341     static KIOTestSlow_base *_fromString(const std::string& objectref);
00342     static KIOTestSlow_base *_fromReference(Arts::ObjectReference ref, bool needcopy);
00343 
00344     static KIOTestSlow_base *_fromDynamicCast(const Arts::Object& object);
00345     inline KIOTestSlow_base *_copy() {
00346         assert(_refCnt > 0);
00347         _refCnt++;
00348         return this;
00349     }
00350 
00351     virtual std::vector<std::string> _defaultPortsIn() const;
00352     virtual std::vector<std::string> _defaultPortsOut() const;
00353 
00354     void *_cast(unsigned long iid);
00355 
00356     virtual Arts::InputStream inputStream() = 0;
00357     virtual void inputStream(Arts::InputStream newValue) = 0;
00358 };
00359 
00360 class KIOTestSlow_stub : virtual public KIOTestSlow_base, virtual public Arts::SynthModule_stub {
00361 protected:
00362     KIOTestSlow_stub();
00363 
00364 public:
00365     KIOTestSlow_stub(Arts::Connection *connection, long objectID);
00366 
00367     Arts::InputStream inputStream();
00368     void inputStream(Arts::InputStream newValue);
00369 };
00370 
00371 class KIOTestSlow_skel : virtual public KIOTestSlow_base, virtual public Arts::SynthModule_skel {
00372 protected:
00373     // variables for streams
00374     Arts::ByteAsyncStream data;               // incoming stream
00375 
00376     // handler for asynchronous streams
00377     virtual void process_data(Arts::DataPacket<Arts::mcopbyte> *) = 0;
00378 
00379 public:
00380     KIOTestSlow_skel();
00381 
00382     static std::string _interfaceNameSkel();
00383     std::string _interfaceName();
00384     bool _isCompatibleWith(const std::string& interfacename);
00385     void _buildMethodTable();
00386     void dispatch(Arts::Buffer *request, Arts::Buffer *result,long methodID);
00387     void notify(const Arts::Notification& notification);
00388 };
00389 
00390 }
00391 #include "reference.h"
00392 namespace Arts {
00393 class KIOTestSlow : public Arts::Object {
00394 private:
00395     static Arts::Object_base* _Creator();
00396     KIOTestSlow_base *_cache;
00397     inline KIOTestSlow_base *_method_call() {
00398         _pool->checkcreate();
00399         if(_pool->base) {
00400             _cache=(KIOTestSlow_base *)_pool->base->_cast(KIOTestSlow_base::_IID);
00401             assert(_cache);
00402         }
00403         return _cache;
00404     }
00405 
00406 protected:
00407     inline KIOTestSlow(KIOTestSlow_base* b) : Arts::Object(b), _cache(0) {}
00408 
00409 
00410 public:
00411     typedef KIOTestSlow_base _base_class;
00412 
00413     inline KIOTestSlow() : Arts::Object(_Creator), _cache(0) {}
00414     inline KIOTestSlow(const Arts::SubClass& s) :
00415         Arts::Object(KIOTestSlow_base::_create(s.string())), _cache(0) {}
00416     inline KIOTestSlow(const Arts::Reference &r) :
00417         Arts::Object(r.isString()?(KIOTestSlow_base::_fromString(r.string())):(KIOTestSlow_base::_fromReference(r.reference(),true))), _cache(0) {}
00418     inline KIOTestSlow(const Arts::DynamicCast& c) : Arts::Object(KIOTestSlow_base::_fromDynamicCast(c.object())), _cache(0) {}
00419     inline KIOTestSlow(const KIOTestSlow& target) : Arts::Object(target._pool), _cache(target._cache) {}
00420     inline KIOTestSlow(Arts::Object::Pool& p) : Arts::Object(p), _cache(0) {}
00421     inline static KIOTestSlow null() {return KIOTestSlow((KIOTestSlow_base*)0);}
00422     inline static KIOTestSlow _from_base(KIOTestSlow_base* b) {return KIOTestSlow(b);}
00423     inline KIOTestSlow& operator=(const KIOTestSlow& target) {
00424         if (_pool == target._pool) return *this;
00425         _pool->Dec();
00426         _pool = target._pool;
00427         _cache = target._cache;
00428         _pool->Inc();
00429         return *this;
00430     }
00431     inline operator Arts::SynthModule() const { return Arts::SynthModule(*_pool); }
00432     inline KIOTestSlow_base* _base() {return _cache?_cache:_method_call();}
00433 
00434     inline Arts::AutoSuspendState autoSuspend();
00435     inline void start();
00436     inline void stop();
00437     inline void streamInit();
00438     inline void streamStart();
00439     inline void streamEnd();
00440     inline Arts::InputStream inputStream();
00441     inline void inputStream(Arts::InputStream _newValue);
00442 };
00443 
00444 }
00445 // Forward wrapper calls to _base classes:
00446 
00447 inline float Arts::KFloatWatchProxy::value()
00448 {
00449     return _cache?static_cast<Arts::KFloatWatchProxy_base*>(_cache)->value():static_cast<Arts::KFloatWatchProxy_base*>(_method_call())->value();
00450 }
00451 
00452 inline void Arts::KFloatWatchProxy::value(float _newValue)
00453 {
00454      _cache?static_cast<Arts::KFloatWatchProxy_base*>(_cache)->value(_newValue):static_cast<Arts::KFloatWatchProxy_base*>(_method_call())->value(_newValue);
00455 }
00456 
00457 inline bool Arts::KIOInputStream::eof()
00458 {
00459     return _cache?static_cast<Arts::InputStream_base*>(_cache)->eof():static_cast<Arts::InputStream_base*>(_method_call())->eof();
00460 }
00461 
00462 inline long Arts::KIOInputStream::size()
00463 {
00464     return _cache?static_cast<Arts::InputStream_base*>(_cache)->size():static_cast<Arts::InputStream_base*>(_method_call())->size();
00465 }
00466 
00467 inline bool Arts::KIOInputStream::seekOk()
00468 {
00469     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seekOk():static_cast<Arts::InputStream_base*>(_method_call())->seekOk();
00470 }
00471 
00472 inline long Arts::KIOInputStream::seek(long position)
00473 {
00474     return _cache?static_cast<Arts::InputStream_base*>(_cache)->seek(position):static_cast<Arts::InputStream_base*>(_method_call())->seek(position);
00475 }
00476 
00477 inline Arts::AutoSuspendState Arts::KIOInputStream::autoSuspend()
00478 {
00479     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
00480 }
00481 
00482 inline void Arts::KIOInputStream::start()
00483 {
00484      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
00485 }
00486 
00487 inline void Arts::KIOInputStream::stop()
00488 {
00489      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
00490 }
00491 
00492 inline void Arts::KIOInputStream::streamInit()
00493 {
00494      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
00495 }
00496 
00497 inline void Arts::KIOInputStream::streamStart()
00498 {
00499      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
00500 }
00501 
00502 inline void Arts::KIOInputStream::streamEnd()
00503 {
00504      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
00505 }
00506 
00507 inline long Arts::KIOInputStream::bufferPackets()
00508 {
00509     return _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->bufferPackets():static_cast<Arts::KIOInputStream_base*>(_method_call())->bufferPackets();
00510 }
00511 
00512 inline void Arts::KIOInputStream::bufferPackets(long _newValue)
00513 {
00514      _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->bufferPackets(_newValue):static_cast<Arts::KIOInputStream_base*>(_method_call())->bufferPackets(_newValue);
00515 }
00516 
00517 inline bool Arts::KIOInputStream::openURL(const std::string& url)
00518 {
00519     return _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->openURL(url):static_cast<Arts::KIOInputStream_base*>(_method_call())->openURL(url);
00520 }
00521 
00522 inline long Arts::KIOInputStream::packetSize()
00523 {
00524     return _cache?static_cast<Arts::KIOInputStream_base*>(_cache)->packetSize():static_cast<Arts::KIOInputStream_base*>(_method_call())->packetSize();
00525 }
00526 
00527 inline Arts::AutoSuspendState Arts::KDataRequest::autoSuspend()
00528 {
00529     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
00530 }
00531 
00532 inline void Arts::KDataRequest::start()
00533 {
00534      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
00535 }
00536 
00537 inline void Arts::KDataRequest::stop()
00538 {
00539      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
00540 }
00541 
00542 inline void Arts::KDataRequest::streamInit()
00543 {
00544      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
00545 }
00546 
00547 inline void Arts::KDataRequest::streamStart()
00548 {
00549      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
00550 }
00551 
00552 inline void Arts::KDataRequest::streamEnd()
00553 {
00554      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
00555 }
00556 
00557 inline void Arts::KDataRequest::goOn()
00558 {
00559      _cache?static_cast<Arts::KDataRequest_base*>(_cache)->goOn():static_cast<Arts::KDataRequest_base*>(_method_call())->goOn();
00560 }
00561 
00562 inline Arts::AutoSuspendState Arts::KIOTestSlow::autoSuspend()
00563 {
00564     return _cache?static_cast<Arts::SynthModule_base*>(_cache)->autoSuspend():static_cast<Arts::SynthModule_base*>(_method_call())->autoSuspend();
00565 }
00566 
00567 inline void Arts::KIOTestSlow::start()
00568 {
00569      _cache?static_cast<Arts::SynthModule_base*>(_cache)->start():static_cast<Arts::SynthModule_base*>(_method_call())->start();
00570 }
00571 
00572 inline void Arts::KIOTestSlow::stop()
00573 {
00574      _cache?static_cast<Arts::SynthModule_base*>(_cache)->stop():static_cast<Arts::SynthModule_base*>(_method_call())->stop();
00575 }
00576 
00577 inline void Arts::KIOTestSlow::streamInit()
00578 {
00579      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamInit():static_cast<Arts::SynthModule_base*>(_method_call())->streamInit();
00580 }
00581 
00582 inline void Arts::KIOTestSlow::streamStart()
00583 {
00584      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamStart():static_cast<Arts::SynthModule_base*>(_method_call())->streamStart();
00585 }
00586 
00587 inline void Arts::KIOTestSlow::streamEnd()
00588 {
00589      _cache?static_cast<Arts::SynthModule_base*>(_cache)->streamEnd():static_cast<Arts::SynthModule_base*>(_method_call())->streamEnd();
00590 }
00591 
00592 inline Arts::InputStream Arts::KIOTestSlow::inputStream()
00593 {
00594     return _cache?static_cast<Arts::KIOTestSlow_base*>(_cache)->inputStream():static_cast<Arts::KIOTestSlow_base*>(_method_call())->inputStream();
00595 }
00596 
00597 inline void Arts::KIOTestSlow::inputStream(Arts::InputStream _newValue)
00598 {
00599      _cache?static_cast<Arts::KIOTestSlow_base*>(_cache)->inputStream(_newValue):static_cast<Arts::KIOTestSlow_base*>(_method_call())->inputStream(_newValue);
00600 }
00601 
00602 #endif /* ARTSKDE_H */
KDE Logo
This file is part of the documentation for arts Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Tue Feb 14 09:17:28 2006 by doxygen 1.3.6 written by Dimitri van Heesch, © 1997-2003