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