artskde.h
00001
00002
00003 #ifndef ARTSKDE_H
00004 #define ARTSKDE_H
00005
00006 #include "common.h"
00007
00008
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;
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
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;
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
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;
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
00270 float *left;
00271 float *right;
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;
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
00374 Arts::ByteAsyncStream data;
00375
00376
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
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
This file is part of the documentation for arts Library Version 3.3.1.