00001
00002
00003 #include "artskde.h"
00004
00005
00006 Arts::KFloatWatchProxy_base *Arts::KFloatWatchProxy_base::_create(const std::string& subClass)
00007 {
00008 Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
00009 assert(skel);
00010 Arts::KFloatWatchProxy_base *castedObject = (Arts::KFloatWatchProxy_base *)skel->_cast(Arts::KFloatWatchProxy_base::_IID);
00011 assert(castedObject);
00012 return castedObject;
00013 }
00014
00015 Arts::KFloatWatchProxy_base *Arts::KFloatWatchProxy_base::_fromString(const std::string& objectref)
00016 {
00017 Arts::ObjectReference r;
00018
00019 if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
00020 return Arts::KFloatWatchProxy_base::_fromReference(r,true);
00021 return 0;
00022 }
00023
00024 Arts::KFloatWatchProxy_base *Arts::KFloatWatchProxy_base::_fromDynamicCast(const Arts::Object& object)
00025 {
00026 if(object.isNull()) return 0;
00027
00028 Arts::KFloatWatchProxy_base *castedObject = (Arts::KFloatWatchProxy_base *)object._base()->_cast(Arts::KFloatWatchProxy_base::_IID);
00029 if(castedObject) return castedObject->_copy();
00030
00031 return _fromString(object._toString());
00032 }
00033
00034 Arts::KFloatWatchProxy_base *Arts::KFloatWatchProxy_base::_fromReference(Arts::ObjectReference r, bool needcopy)
00035 {
00036 Arts::KFloatWatchProxy_base *result;
00037 result = (Arts::KFloatWatchProxy_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::KFloatWatchProxy");
00038 if(result)
00039 {
00040 if(!needcopy)
00041 result->_cancelCopyRemote();
00042 }
00043 else
00044 {
00045 Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
00046 if(conn)
00047 {
00048 result = new Arts::KFloatWatchProxy_stub(conn,r.objectID);
00049 if(needcopy) result->_copyRemote();
00050 result->_useRemote();
00051 if (!result->_isCompatibleWith("Arts::KFloatWatchProxy")) {
00052 result->_release();
00053 return 0;
00054 }
00055 }
00056 }
00057 return result;
00058 }
00059
00060 std::vector<std::string> Arts::KFloatWatchProxy_base::_defaultPortsIn() const {
00061 std::vector<std::string> ret;
00062 return ret;
00063 }
00064 std::vector<std::string> Arts::KFloatWatchProxy_base::_defaultPortsOut() const {
00065 std::vector<std::string> ret;
00066 return ret;
00067 }
00068
00069 void *Arts::KFloatWatchProxy_base::_cast(unsigned long iid)
00070 {
00071 if(iid == Arts::KFloatWatchProxy_base::_IID) return (Arts::KFloatWatchProxy_base *)this;
00072 if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
00073 return 0;
00074 }
00075
00076 Arts::KFloatWatchProxy_stub::KFloatWatchProxy_stub()
00077 {
00078
00079 }
00080
00081 Arts::KFloatWatchProxy_stub::KFloatWatchProxy_stub(Arts::Connection *connection, long objectID)
00082 : Arts::Object_stub(connection, objectID)
00083 {
00084
00085 }
00086
00087 float Arts::KFloatWatchProxy_stub::value()
00088 {
00089 long methodID = _lookupMethodFast("method:0000000b5f6765745f76616c75650000000006666c6f617400000000020000000000000000");
00090 long requestID;
00091 Arts::Buffer *request, *result;
00092 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00093 request->patchLength();
00094 _connection->qSendBuffer(request);
00095
00096 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00097 if(!result) return 0.0;
00098 float returnCode = result->readFloat();
00099 delete result;
00100 return returnCode;
00101 }
00102
00103 void Arts::KFloatWatchProxy_stub::value(float newValue)
00104 {
00105 long methodID = _lookupMethodFast("method:0000000b5f7365745f76616c75650000000005766f696400000000020000000100000006666c6f617400000000096e657756616c7565000000000000000000");
00106 long requestID;
00107 Arts::Buffer *request, *result;
00108 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00109 request->writeFloat(newValue);
00110 request->patchLength();
00111 _connection->qSendBuffer(request);
00112
00113 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00114 if(result) delete result;
00115 }
00116
00117 std::string Arts::KFloatWatchProxy_skel::_interfaceName()
00118 {
00119 return "Arts::KFloatWatchProxy";
00120 }
00121
00122 bool Arts::KFloatWatchProxy_skel::_isCompatibleWith(const std::string& interfacename)
00123 {
00124 if (interfacename == "Arts::KFloatWatchProxy") return true;
00125 if (interfacename == "Arts::Object") return true;
00126 return false;
00127 }
00128
00129 std::string Arts::KFloatWatchProxy_skel::_interfaceNameSkel()
00130 {
00131 return "Arts::KFloatWatchProxy";
00132 }
00133
00134
00135 static void _dispatch_Arts_KFloatWatchProxy_00(void *object, Arts::Buffer *, Arts::Buffer *result)
00136 {
00137 result->writeFloat(((Arts::KFloatWatchProxy_skel *)object)->value());
00138 }
00139
00140
00141 static void _dispatch_Arts_KFloatWatchProxy_01(void *object, Arts::Buffer *request, Arts::Buffer *)
00142 {
00143 float newValue = request->readFloat();
00144 ((Arts::KFloatWatchProxy_skel *)object)->value(newValue);
00145 }
00146
00147 void Arts::KFloatWatchProxy_skel::_buildMethodTable()
00148 {
00149 Arts::Buffer m;
00150 m.fromString(
00151 "MethodTable:0000000b5f6765745f76616c75650000000006666c6f6174000000"
00152 "000200000000000000000000000b5f7365745f76616c75650000000005766f6964"
00153 "00000000020000000100000006666c6f617400000000096e657756616c75650000"
00154 "00000000000000",
00155 "MethodTable"
00156 );
00157 _addMethod(_dispatch_Arts_KFloatWatchProxy_00,this,Arts::MethodDef(m));
00158 _addMethod(_dispatch_Arts_KFloatWatchProxy_01,this,Arts::MethodDef(m));
00159 }
00160
00161 Arts::KFloatWatchProxy_skel::KFloatWatchProxy_skel()
00162 {
00163 }
00164
00165 Arts::Object_base* Arts::KFloatWatchProxy::_Creator() {
00166 return Arts::KFloatWatchProxy_base::_create();
00167 }
00168
00169 unsigned long Arts::KFloatWatchProxy_base::_IID = Arts::MCOPUtils::makeIID("Arts::KFloatWatchProxy");
00170
00171 Arts::KIOInputStream_base *Arts::KIOInputStream_base::_create(const std::string& subClass)
00172 {
00173 Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
00174 assert(skel);
00175 Arts::KIOInputStream_base *castedObject = (Arts::KIOInputStream_base *)skel->_cast(Arts::KIOInputStream_base::_IID);
00176 assert(castedObject);
00177 return castedObject;
00178 }
00179
00180 Arts::KIOInputStream_base *Arts::KIOInputStream_base::_fromString(const std::string& objectref)
00181 {
00182 Arts::ObjectReference r;
00183
00184 if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
00185 return Arts::KIOInputStream_base::_fromReference(r,true);
00186 return 0;
00187 }
00188
00189 Arts::KIOInputStream_base *Arts::KIOInputStream_base::_fromDynamicCast(const Arts::Object& object)
00190 {
00191 if(object.isNull()) return 0;
00192
00193 Arts::KIOInputStream_base *castedObject = (Arts::KIOInputStream_base *)object._base()->_cast(Arts::KIOInputStream_base::_IID);
00194 if(castedObject) return castedObject->_copy();
00195
00196 return _fromString(object._toString());
00197 }
00198
00199 Arts::KIOInputStream_base *Arts::KIOInputStream_base::_fromReference(Arts::ObjectReference r, bool needcopy)
00200 {
00201 Arts::KIOInputStream_base *result;
00202 result = (Arts::KIOInputStream_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::KIOInputStream");
00203 if(result)
00204 {
00205 if(!needcopy)
00206 result->_cancelCopyRemote();
00207 }
00208 else
00209 {
00210 Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
00211 if(conn)
00212 {
00213 result = new Arts::KIOInputStream_stub(conn,r.objectID);
00214 if(needcopy) result->_copyRemote();
00215 result->_useRemote();
00216 if (!result->_isCompatibleWith("Arts::KIOInputStream")) {
00217 result->_release();
00218 return 0;
00219 }
00220 }
00221 }
00222 return result;
00223 }
00224
00225 std::vector<std::string> Arts::KIOInputStream_base::_defaultPortsIn() const {
00226 std::vector<std::string> ret;
00227 return ret;
00228 }
00229 std::vector<std::string> Arts::KIOInputStream_base::_defaultPortsOut() const {
00230 std::vector<std::string> ret;
00231 ret.push_back("outdata");
00232 return ret;
00233 }
00234
00235 void *Arts::KIOInputStream_base::_cast(unsigned long iid)
00236 {
00237 if(iid == Arts::KIOInputStream_base::_IID) return (Arts::KIOInputStream_base *)this;
00238 if(iid == Arts::InputStream_base::_IID) return (Arts::InputStream_base *)this;
00239 if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
00240 if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
00241 return 0;
00242 }
00243
00244 Arts::KIOInputStream_stub::KIOInputStream_stub()
00245 {
00246
00247 }
00248
00249 Arts::KIOInputStream_stub::KIOInputStream_stub(Arts::Connection *connection, long objectID)
00250 : Arts::Object_stub(connection, objectID)
00251 {
00252
00253 }
00254
00255 bool Arts::KIOInputStream_stub::openURL(const std::string& url)
00256 {
00257 long methodID = _lookupMethodFast("method:000000086f70656e55524c0000000008626f6f6c65616e00000000020000000100000007737472696e67000000000475726c000000000000000000");
00258 long requestID;
00259 Arts::Buffer *request, *result;
00260 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00261 request->writeString(url);
00262 request->patchLength();
00263 _connection->qSendBuffer(request);
00264
00265 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00266 if(!result) return false;
00267 bool returnCode = result->readBool();
00268 delete result;
00269 return returnCode;
00270 }
00271
00272 long Arts::KIOInputStream_stub::packetSize()
00273 {
00274 long methodID = _lookupMethodFast("method:0000000b7061636b657453697a6500000000056c6f6e6700000000020000000000000000");
00275 long requestID;
00276 Arts::Buffer *request, *result;
00277 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00278 request->patchLength();
00279 _connection->qSendBuffer(request);
00280
00281 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00282 if(!result) return 0;
00283 long returnCode = result->readLong();
00284 delete result;
00285 return returnCode;
00286 }
00287
00288 long Arts::KIOInputStream_stub::bufferPackets()
00289 {
00290 long methodID = _lookupMethodFast("method:000000135f6765745f6275666665725061636b65747300000000056c6f6e6700000000020000000000000000");
00291 long requestID;
00292 Arts::Buffer *request, *result;
00293 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00294 request->patchLength();
00295 _connection->qSendBuffer(request);
00296
00297 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00298 if(!result) return 0;
00299 long returnCode = result->readLong();
00300 delete result;
00301 return returnCode;
00302 }
00303
00304 void Arts::KIOInputStream_stub::bufferPackets(long newValue)
00305 {
00306 long methodID = _lookupMethodFast("method:000000135f7365745f6275666665725061636b6574730000000005766f6964000000000200000001000000056c6f6e6700000000096e657756616c7565000000000000000000");
00307 long requestID;
00308 Arts::Buffer *request, *result;
00309 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00310 request->writeLong(newValue);
00311 request->patchLength();
00312 _connection->qSendBuffer(request);
00313
00314 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00315 if(result) delete result;
00316 }
00317
00318 std::string Arts::KIOInputStream_skel::_interfaceName()
00319 {
00320 return "Arts::KIOInputStream";
00321 }
00322
00323 bool Arts::KIOInputStream_skel::_isCompatibleWith(const std::string& interfacename)
00324 {
00325 if (interfacename == "Arts::KIOInputStream") return true;
00326 if (interfacename == "Arts::InputStream") return true;
00327 if (interfacename == "Arts::SynthModule") return true;
00328 if (interfacename == "Arts::Object") return true;
00329 return false;
00330 }
00331
00332 std::string Arts::KIOInputStream_skel::_interfaceNameSkel()
00333 {
00334 return "Arts::KIOInputStream";
00335 }
00336
00337
00338 static void _dispatch_Arts_KIOInputStream_00(void *object, Arts::Buffer *request, Arts::Buffer *result)
00339 {
00340 std::string url;
00341 request->readString(url);
00342 result->writeBool(((Arts::KIOInputStream_skel *)object)->openURL(url));
00343 }
00344
00345
00346 static void _dispatch_Arts_KIOInputStream_01(void *object, Arts::Buffer *, Arts::Buffer *result)
00347 {
00348 result->writeLong(((Arts::KIOInputStream_skel *)object)->packetSize());
00349 }
00350
00351
00352 static void _dispatch_Arts_KIOInputStream_02(void *object, Arts::Buffer *, Arts::Buffer *result)
00353 {
00354 result->writeLong(((Arts::KIOInputStream_skel *)object)->bufferPackets());
00355 }
00356
00357
00358 static void _dispatch_Arts_KIOInputStream_03(void *object, Arts::Buffer *request, Arts::Buffer *)
00359 {
00360 long newValue = request->readLong();
00361 ((Arts::KIOInputStream_skel *)object)->bufferPackets(newValue);
00362 }
00363
00364 void Arts::KIOInputStream_skel::_buildMethodTable()
00365 {
00366 Arts::Buffer m;
00367 m.fromString(
00368 "MethodTable:000000086f70656e55524c0000000008626f6f6c65616e00000000"
00369 "020000000100000007737472696e67000000000475726c00000000000000000000"
00370 "00000b7061636b657453697a6500000000056c6f6e670000000002000000000000"
00371 "0000000000135f6765745f6275666665725061636b65747300000000056c6f6e67"
00372 "00000000020000000000000000000000135f7365745f6275666665725061636b65"
00373 "74730000000005766f6964000000000200000001000000056c6f6e670000000009"
00374 "6e657756616c7565000000000000000000",
00375 "MethodTable"
00376 );
00377 _addMethod(_dispatch_Arts_KIOInputStream_00,this,Arts::MethodDef(m));
00378 _addMethod(_dispatch_Arts_KIOInputStream_01,this,Arts::MethodDef(m));
00379 _addMethod(_dispatch_Arts_KIOInputStream_02,this,Arts::MethodDef(m));
00380 _addMethod(_dispatch_Arts_KIOInputStream_03,this,Arts::MethodDef(m));
00381 Arts::InputStream_skel::_buildMethodTable();
00382 }
00383
00384 Arts::KIOInputStream_skel::KIOInputStream_skel()
00385 {
00386 }
00387
00388 Arts::Object_base* Arts::KIOInputStream::_Creator() {
00389 return Arts::KIOInputStream_base::_create();
00390 }
00391
00392 unsigned long Arts::KIOInputStream_base::_IID = Arts::MCOPUtils::makeIID("Arts::KIOInputStream");
00393
00394 Arts::KDataRequest_base *Arts::KDataRequest_base::_create(const std::string& subClass)
00395 {
00396 Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
00397 assert(skel);
00398 Arts::KDataRequest_base *castedObject = (Arts::KDataRequest_base *)skel->_cast(Arts::KDataRequest_base::_IID);
00399 assert(castedObject);
00400 return castedObject;
00401 }
00402
00403 Arts::KDataRequest_base *Arts::KDataRequest_base::_fromString(const std::string& objectref)
00404 {
00405 Arts::ObjectReference r;
00406
00407 if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
00408 return Arts::KDataRequest_base::_fromReference(r,true);
00409 return 0;
00410 }
00411
00412 Arts::KDataRequest_base *Arts::KDataRequest_base::_fromDynamicCast(const Arts::Object& object)
00413 {
00414 if(object.isNull()) return 0;
00415
00416 Arts::KDataRequest_base *castedObject = (Arts::KDataRequest_base *)object._base()->_cast(Arts::KDataRequest_base::_IID);
00417 if(castedObject) return castedObject->_copy();
00418
00419 return _fromString(object._toString());
00420 }
00421
00422 Arts::KDataRequest_base *Arts::KDataRequest_base::_fromReference(Arts::ObjectReference r, bool needcopy)
00423 {
00424 Arts::KDataRequest_base *result;
00425 result = (Arts::KDataRequest_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::KDataRequest");
00426 if(result)
00427 {
00428 if(!needcopy)
00429 result->_cancelCopyRemote();
00430 }
00431 else
00432 {
00433 Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
00434 if(conn)
00435 {
00436 result = new Arts::KDataRequest_stub(conn,r.objectID);
00437 if(needcopy) result->_copyRemote();
00438 result->_useRemote();
00439 if (!result->_isCompatibleWith("Arts::KDataRequest")) {
00440 result->_release();
00441 return 0;
00442 }
00443 }
00444 }
00445 return result;
00446 }
00447
00448 std::vector<std::string> Arts::KDataRequest_base::_defaultPortsIn() const {
00449 std::vector<std::string> ret;
00450 ret.push_back("left");
00451 ret.push_back("right");
00452 return ret;
00453 }
00454 std::vector<std::string> Arts::KDataRequest_base::_defaultPortsOut() const {
00455 std::vector<std::string> ret;
00456 return ret;
00457 }
00458
00459 void *Arts::KDataRequest_base::_cast(unsigned long iid)
00460 {
00461 if(iid == Arts::KDataRequest_base::_IID) return (Arts::KDataRequest_base *)this;
00462 if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
00463 if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
00464 return 0;
00465 }
00466
00467 Arts::KDataRequest_stub::KDataRequest_stub()
00468 {
00469
00470 }
00471
00472 Arts::KDataRequest_stub::KDataRequest_stub(Arts::Connection *connection, long objectID)
00473 : Arts::Object_stub(connection, objectID)
00474 {
00475
00476 }
00477
00478 void Arts::KDataRequest_stub::goOn()
00479 {
00480 long methodID = _lookupMethodFast("method:00000005676f4f6e0000000005766f696400000000020000000000000000");
00481 long requestID;
00482 Arts::Buffer *request, *result;
00483 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00484 request->patchLength();
00485 _connection->qSendBuffer(request);
00486
00487 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00488 if(result) delete result;
00489 }
00490
00491 std::string Arts::KDataRequest_skel::_interfaceName()
00492 {
00493 return "Arts::KDataRequest";
00494 }
00495
00496 bool Arts::KDataRequest_skel::_isCompatibleWith(const std::string& interfacename)
00497 {
00498 if (interfacename == "Arts::KDataRequest") return true;
00499 if (interfacename == "Arts::SynthModule") return true;
00500 if (interfacename == "Arts::Object") return true;
00501 return false;
00502 }
00503
00504 std::string Arts::KDataRequest_skel::_interfaceNameSkel()
00505 {
00506 return "Arts::KDataRequest";
00507 }
00508
00509
00510 static void _dispatch_Arts_KDataRequest_00(void *object, Arts::Buffer *, Arts::Buffer *)
00511 {
00512 ((Arts::KDataRequest_skel *)object)->goOn();
00513 }
00514
00515 void Arts::KDataRequest_skel::_buildMethodTable()
00516 {
00517 Arts::Buffer m;
00518 m.fromString(
00519 "MethodTable:00000005676f4f6e0000000005766f696400000000020000000000"
00520 "000000",
00521 "MethodTable"
00522 );
00523 _addMethod(_dispatch_Arts_KDataRequest_00,this,Arts::MethodDef(m));
00524 Arts::SynthModule_skel::_buildMethodTable();
00525 }
00526
00527 Arts::KDataRequest_skel::KDataRequest_skel()
00528 {
00529 _initStream("left",&left,73);
00530 _initStream("right",&right,73);
00531 }
00532
00533 Arts::Object_base* Arts::KDataRequest::_Creator() {
00534 return Arts::KDataRequest_base::_create();
00535 }
00536
00537 unsigned long Arts::KDataRequest_base::_IID = Arts::MCOPUtils::makeIID("Arts::KDataRequest");
00538
00539 Arts::KIOTestSlow_base *Arts::KIOTestSlow_base::_create(const std::string& subClass)
00540 {
00541 Arts::Object_skel *skel = Arts::ObjectManager::the()->create(subClass);
00542 assert(skel);
00543 Arts::KIOTestSlow_base *castedObject = (Arts::KIOTestSlow_base *)skel->_cast(Arts::KIOTestSlow_base::_IID);
00544 assert(castedObject);
00545 return castedObject;
00546 }
00547
00548 Arts::KIOTestSlow_base *Arts::KIOTestSlow_base::_fromString(const std::string& objectref)
00549 {
00550 Arts::ObjectReference r;
00551
00552 if(Arts::Dispatcher::the()->stringToObjectReference(r,objectref))
00553 return Arts::KIOTestSlow_base::_fromReference(r,true);
00554 return 0;
00555 }
00556
00557 Arts::KIOTestSlow_base *Arts::KIOTestSlow_base::_fromDynamicCast(const Arts::Object& object)
00558 {
00559 if(object.isNull()) return 0;
00560
00561 Arts::KIOTestSlow_base *castedObject = (Arts::KIOTestSlow_base *)object._base()->_cast(Arts::KIOTestSlow_base::_IID);
00562 if(castedObject) return castedObject->_copy();
00563
00564 return _fromString(object._toString());
00565 }
00566
00567 Arts::KIOTestSlow_base *Arts::KIOTestSlow_base::_fromReference(Arts::ObjectReference r, bool needcopy)
00568 {
00569 Arts::KIOTestSlow_base *result;
00570 result = (Arts::KIOTestSlow_base *)Arts::Dispatcher::the()->connectObjectLocal(r,"Arts::KIOTestSlow");
00571 if(result)
00572 {
00573 if(!needcopy)
00574 result->_cancelCopyRemote();
00575 }
00576 else
00577 {
00578 Arts::Connection *conn = Arts::Dispatcher::the()->connectObjectRemote(r);
00579 if(conn)
00580 {
00581 result = new Arts::KIOTestSlow_stub(conn,r.objectID);
00582 if(needcopy) result->_copyRemote();
00583 result->_useRemote();
00584 if (!result->_isCompatibleWith("Arts::KIOTestSlow")) {
00585 result->_release();
00586 return 0;
00587 }
00588 }
00589 }
00590 return result;
00591 }
00592
00593 std::vector<std::string> Arts::KIOTestSlow_base::_defaultPortsIn() const {
00594 std::vector<std::string> ret;
00595 ret.push_back("data");
00596 return ret;
00597 }
00598 std::vector<std::string> Arts::KIOTestSlow_base::_defaultPortsOut() const {
00599 std::vector<std::string> ret;
00600 return ret;
00601 }
00602
00603 void *Arts::KIOTestSlow_base::_cast(unsigned long iid)
00604 {
00605 if(iid == Arts::KIOTestSlow_base::_IID) return (Arts::KIOTestSlow_base *)this;
00606 if(iid == Arts::SynthModule_base::_IID) return (Arts::SynthModule_base *)this;
00607 if(iid == Arts::Object_base::_IID) return (Arts::Object_base *)this;
00608 return 0;
00609 }
00610
00611 Arts::KIOTestSlow_stub::KIOTestSlow_stub()
00612 {
00613
00614 }
00615
00616 Arts::KIOTestSlow_stub::KIOTestSlow_stub(Arts::Connection *connection, long objectID)
00617 : Arts::Object_stub(connection, objectID)
00618 {
00619
00620 }
00621
00622 Arts::InputStream Arts::KIOTestSlow_stub::inputStream()
00623 {
00624 long methodID = _lookupMethodFast("method:000000115f6765745f696e70757453747265616d0000000012417274733a3a496e70757453747265616d00000000020000000000000000");
00625 long requestID;
00626 Arts::Buffer *request, *result;
00627 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00628 request->patchLength();
00629 _connection->qSendBuffer(request);
00630
00631 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00632 if (!result) return Arts::InputStream::null();
00633 Arts::InputStream_base* returnCode;
00634 Arts::readObject(*result,returnCode);
00635 delete result;
00636 return Arts::InputStream::_from_base(returnCode);
00637 }
00638
00639 void Arts::KIOTestSlow_stub::inputStream(Arts::InputStream newValue)
00640 {
00641 long methodID = _lookupMethodFast("method:000000115f7365745f696e70757453747265616d0000000005766f696400000000020000000100000012417274733a3a496e70757453747265616d00000000096e657756616c7565000000000000000000");
00642 long requestID;
00643 Arts::Buffer *request, *result;
00644 request = Arts::Dispatcher::the()->createRequest(requestID,_objectID,methodID);
00645 Arts::writeObject(*request,newValue._base());
00646 request->patchLength();
00647 _connection->qSendBuffer(request);
00648
00649 result = Arts::Dispatcher::the()->waitForResult(requestID,_connection);
00650 if(result) delete result;
00651 }
00652
00653 std::string Arts::KIOTestSlow_skel::_interfaceName()
00654 {
00655 return "Arts::KIOTestSlow";
00656 }
00657
00658 bool Arts::KIOTestSlow_skel::_isCompatibleWith(const std::string& interfacename)
00659 {
00660 if (interfacename == "Arts::KIOTestSlow") return true;
00661 if (interfacename == "Arts::SynthModule") return true;
00662 if (interfacename == "Arts::Object") return true;
00663 return false;
00664 }
00665
00666 std::string Arts::KIOTestSlow_skel::_interfaceNameSkel()
00667 {
00668 return "Arts::KIOTestSlow";
00669 }
00670
00671
00672 static void _dispatch_Arts_KIOTestSlow_00(void *object, Arts::Buffer *, Arts::Buffer *result)
00673 {
00674 Arts::InputStream returnCode = ((Arts::KIOTestSlow_skel *)object)->inputStream();
00675 Arts::writeObject(*result,returnCode._base());
00676 }
00677
00678
00679 static void _dispatch_Arts_KIOTestSlow_01(void *object, Arts::Buffer *request, Arts::Buffer *)
00680 {
00681 Arts::InputStream_base* _temp_newValue;
00682 Arts::readObject(*request,_temp_newValue);
00683 Arts::InputStream newValue = Arts::InputStream::_from_base(_temp_newValue);
00684 ((Arts::KIOTestSlow_skel *)object)->inputStream(newValue);
00685 }
00686
00687 void Arts::KIOTestSlow_skel::_buildMethodTable()
00688 {
00689 Arts::Buffer m;
00690 m.fromString(
00691 "MethodTable:000000115f6765745f696e70757453747265616d00000000124172"
00692 "74733a3a496e70757453747265616d00000000020000000000000000000000115f"
00693 "7365745f696e70757453747265616d0000000005766f6964000000000200000001"
00694 "00000012417274733a3a496e70757453747265616d00000000096e657756616c75"
00695 "65000000000000000000",
00696 "MethodTable"
00697 );
00698 _addMethod(_dispatch_Arts_KIOTestSlow_00,this,Arts::MethodDef(m));
00699 _addMethod(_dispatch_Arts_KIOTestSlow_01,this,Arts::MethodDef(m));
00700 Arts::SynthModule_skel::_buildMethodTable();
00701 }
00702
00703 Arts::KIOTestSlow_skel::KIOTestSlow_skel()
00704 {
00705 _initStream("data",&data,41);
00706 }
00707
00708 void Arts::KIOTestSlow_skel::notify(const Arts::Notification ¬ification)
00709 {
00710 if(data.notifyID() == notification.ID)
00711 process_data((Arts::DataPacket<Arts::mcopbyte> *)notification.data);
00712 }
00713
00714 Arts::Object_base* Arts::KIOTestSlow::_Creator() {
00715 return Arts::KIOTestSlow_base::_create();
00716 }
00717
00718 unsigned long Arts::KIOTestSlow_base::_IID = Arts::MCOPUtils::makeIID("Arts::KIOTestSlow");
00719
00720 static Arts::IDLFileReg IDLFileReg_artskde("artskde",
00721 "IDLFile:000000010000000000000000000000000400000017417274733a3a4b466c6f"
00722 "6174576174636850726f7879000000000000000000000000010000000676616c756500"
00723 "00000006666c6f6174000000001300000000000000000000000000000015417274733a"
00724 "3a4b494f496e70757453747265616d000000000100000012417274733a3a496e707574"
00725 "53747265616d0000000002000000086f70656e55524c0000000008626f6f6c65616e00"
00726 "000000020000000100000007737472696e67000000000475726c000000000000000000"
00727 "0000000b7061636b657453697a6500000000056c6f6e67000000000200000000000000"
00728 "00000000010000000e6275666665725061636b65747300000000056c6f6e6700000000"
00729 "1300000000000000000000000000000013417274733a3a4b4461746152657175657374"
00730 "000000000100000012417274733a3a53796e74684d6f64756c65000000000100000005"
00731 "676f4f6e0000000005766f69640000000002000000000000000000000002000000056c"
00732 "6566740000000006666c6f617400000000490000000000000006726967687400000000"
00733 "06666c6f617400000000490000000000000002000000056c6566740000000006726967"
00734 "6874000000000000000012417274733a3a4b494f54657374536c6f7700000000010000"
00735 "0012417274733a3a53796e74684d6f64756c6500000000000000000200000005646174"
00736 "610000000005627974650000000029000000000000000c696e70757453747265616d00"
00737 "00000012417274733a3a496e70757453747265616d0000000013000000000000000000"
00738 "00000000000000"
00739 );