00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include <IRobot.ice.H>
00014 #include <Ice/LocalException.h>
00015 #include <Ice/ObjectFactory.h>
00016 #include <Ice/BasicStream.h>
00017 #include <IceUtil/Iterator.h>
00018 #include <IceUtil/ScopedArray.h>
00019
00020 #ifndef ICE_IGNORE_VERSION
00021 # if ICE_INT_VERSION / 100 != 303
00022 # error Ice version mismatch!
00023 # endif
00024 # if ICE_INT_VERSION % 100 > 50
00025 # error Beta header file detected
00026 # endif
00027 # if ICE_INT_VERSION % 100 < 1
00028 # error Ice patch level mismatch!
00029 # endif
00030 #endif
00031
00032 static const ::std::string __Robots__IRobot__getSpeed_name = "getSpeed";
00033
00034 static const ::std::string __Robots__IRobot__setSpeed_name = "setSpeed";
00035
00036 static const ::std::string __Robots__IRobot__getSteering_name = "getSteering";
00037
00038 static const ::std::string __Robots__IRobot__setSteering_name = "setSteering";
00039
00040 static const ::std::string __Robots__IRobot__getImageSensor_name = "getImageSensor";
00041
00042 static const ::std::string __Robots__IRobot__getImageSensorDims_name = "getImageSensorDims";
00043
00044 static const ::std::string __Robots__IRobot__getSensorValue_name = "getSensorValue";
00045
00046 static const ::std::string __Robots__IRobot__getSensors_name = "getSensors";
00047
00048 static const ::std::string __Robots__IRobot__getDistanceAngle_name = "getDistanceAngle";
00049
00050 static const ::std::string __Robots__IRobot__motorsOff_name = "motorsOff";
00051
00052 static const ::std::string __Robots__IRobot__setMotor_name = "setMotor";
00053
00054 static const ::std::string __Robots__IRobot__sendRawCmd_name = "sendRawCmd";
00055
00056 static const ::std::string __Robots__IRobot__playSong_name = "playSong";
00057
00058 static const ::std::string __Robots__IRobot__sendStart_name = "sendStart";
00059
00060 static const ::std::string __Robots__IRobot__setMode_name = "setMode";
00061
00062 static const ::std::string __Robots__IRobot__setDemo_name = "setDemo";
00063
00064 static const ::std::string __Robots__IRobot__setLED_name = "setLED";
00065
00066 static const ::std::string __Robots__IRobot__shutdown_name = "shutdown";
00067
00068 ::Ice::Object* IceInternal::upCast(::Robots::IRobot* p) { return p; }
00069 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::Robots::IRobot* p) { return p; }
00070
00071 void
00072 Robots::__read(::IceInternal::BasicStream* __is, ::Robots::IRobotPrx& v)
00073 {
00074 ::Ice::ObjectPrx proxy;
00075 __is->read(proxy);
00076 if(!proxy)
00077 {
00078 v = 0;
00079 }
00080 else
00081 {
00082 v = new ::IceProxy::Robots::IRobot;
00083 v->__copyFrom(proxy);
00084 }
00085 }
00086
00087 void
00088 Robots::__write(::IceInternal::BasicStream* __os, ::Robots::IRobotModes v)
00089 {
00090 __os->write(static_cast< ::Ice::Byte>(v), 5);
00091 }
00092
00093 void
00094 Robots::__read(::IceInternal::BasicStream* __is, ::Robots::IRobotModes& v)
00095 {
00096 ::Ice::Byte val;
00097 __is->read(val, 5);
00098 v = static_cast< ::Robots::IRobotModes>(val);
00099 }
00100
00101 ::Ice::Float
00102 IceProxy::Robots::IRobot::getSpeed(const ::Ice::Context* __ctx)
00103 {
00104 int __cnt = 0;
00105 while(true)
00106 {
00107 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00108 try
00109 {
00110 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00111 IceUtil::DummyBCC dummy;
00112 #endif
00113 __checkTwowayOnly(__Robots__IRobot__getSpeed_name);
00114 __delBase = __getDelegate(false);
00115 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00116 return __del->getSpeed(__ctx);
00117 }
00118 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00119 {
00120 __handleExceptionWrapper(__delBase, __ex, 0);
00121 }
00122 catch(const ::Ice::LocalException& __ex)
00123 {
00124 __handleException(__delBase, __ex, 0, __cnt);
00125 }
00126 }
00127 }
00128
00129 ::Ice::Short
00130 IceProxy::Robots::IRobot::setSpeed(::Ice::Float speed, const ::Ice::Context* __ctx)
00131 {
00132 int __cnt = 0;
00133 while(true)
00134 {
00135 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00136 try
00137 {
00138 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00139 IceUtil::DummyBCC dummy;
00140 #endif
00141 __checkTwowayOnly(__Robots__IRobot__setSpeed_name);
00142 __delBase = __getDelegate(false);
00143 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00144 return __del->setSpeed(speed, __ctx);
00145 }
00146 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00147 {
00148 __handleExceptionWrapper(__delBase, __ex, 0);
00149 }
00150 catch(const ::Ice::LocalException& __ex)
00151 {
00152 __handleException(__delBase, __ex, 0, __cnt);
00153 }
00154 }
00155 }
00156
00157 ::Ice::Float
00158 IceProxy::Robots::IRobot::getSteering(const ::Ice::Context* __ctx)
00159 {
00160 int __cnt = 0;
00161 while(true)
00162 {
00163 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00164 try
00165 {
00166 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00167 IceUtil::DummyBCC dummy;
00168 #endif
00169 __checkTwowayOnly(__Robots__IRobot__getSteering_name);
00170 __delBase = __getDelegate(false);
00171 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00172 return __del->getSteering(__ctx);
00173 }
00174 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00175 {
00176 __handleExceptionWrapper(__delBase, __ex, 0);
00177 }
00178 catch(const ::Ice::LocalException& __ex)
00179 {
00180 __handleException(__delBase, __ex, 0, __cnt);
00181 }
00182 }
00183 }
00184
00185 ::Ice::Short
00186 IceProxy::Robots::IRobot::setSteering(::Ice::Float steeringPos, const ::Ice::Context* __ctx)
00187 {
00188 int __cnt = 0;
00189 while(true)
00190 {
00191 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00192 try
00193 {
00194 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00195 IceUtil::DummyBCC dummy;
00196 #endif
00197 __checkTwowayOnly(__Robots__IRobot__setSteering_name);
00198 __delBase = __getDelegate(false);
00199 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00200 return __del->setSteering(steeringPos, __ctx);
00201 }
00202 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00203 {
00204 __handleExceptionWrapper(__delBase, __ex, 0);
00205 }
00206 catch(const ::Ice::LocalException& __ex)
00207 {
00208 __handleException(__delBase, __ex, 0, __cnt);
00209 }
00210 }
00211 }
00212
00213 ::ImageIceMod::ImageIce
00214 IceProxy::Robots::IRobot::getImageSensor(::Ice::Short i, bool useColor, const ::Ice::Context* __ctx)
00215 {
00216 int __cnt = 0;
00217 while(true)
00218 {
00219 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00220 try
00221 {
00222 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00223 IceUtil::DummyBCC dummy;
00224 #endif
00225 __checkTwowayOnly(__Robots__IRobot__getImageSensor_name);
00226 __delBase = __getDelegate(false);
00227 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00228 return __del->getImageSensor(i, useColor, __ctx);
00229 }
00230 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00231 {
00232 __handleExceptionWrapper(__delBase, __ex, 0);
00233 }
00234 catch(const ::Ice::LocalException& __ex)
00235 {
00236 __handleException(__delBase, __ex, 0, __cnt);
00237 }
00238 }
00239 }
00240
00241 ::ImageIceMod::DimsIce
00242 IceProxy::Robots::IRobot::getImageSensorDims(::Ice::Short i, const ::Ice::Context* __ctx)
00243 {
00244 int __cnt = 0;
00245 while(true)
00246 {
00247 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00248 try
00249 {
00250 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00251 IceUtil::DummyBCC dummy;
00252 #endif
00253 __checkTwowayOnly(__Robots__IRobot__getImageSensorDims_name);
00254 __delBase = __getDelegate(false);
00255 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00256 return __del->getImageSensorDims(i, __ctx);
00257 }
00258 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00259 {
00260 __handleExceptionWrapper(__delBase, __ex, 0);
00261 }
00262 catch(const ::Ice::LocalException& __ex)
00263 {
00264 __handleException(__delBase, __ex, 0, __cnt);
00265 }
00266 }
00267 }
00268
00269 ::Ice::Float
00270 IceProxy::Robots::IRobot::getSensorValue(::Ice::Short i, const ::Ice::Context* __ctx)
00271 {
00272 int __cnt = 0;
00273 while(true)
00274 {
00275 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00276 try
00277 {
00278 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00279 IceUtil::DummyBCC dummy;
00280 #endif
00281 __checkTwowayOnly(__Robots__IRobot__getSensorValue_name);
00282 __delBase = __getDelegate(false);
00283 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00284 return __del->getSensorValue(i, __ctx);
00285 }
00286 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00287 {
00288 __handleExceptionWrapper(__delBase, __ex, 0);
00289 }
00290 catch(const ::Ice::LocalException& __ex)
00291 {
00292 __handleException(__delBase, __ex, 0, __cnt);
00293 }
00294 }
00295 }
00296
00297 bool
00298 IceProxy::Robots::IRobot::getSensors(::Ice::Float& xPos, ::Ice::Float& yPos, ::Ice::Float& ori, const ::Ice::Context* __ctx)
00299 {
00300 int __cnt = 0;
00301 while(true)
00302 {
00303 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00304 try
00305 {
00306 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00307 IceUtil::DummyBCC dummy;
00308 #endif
00309 __checkTwowayOnly(__Robots__IRobot__getSensors_name);
00310 __delBase = __getDelegate(false);
00311 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00312 return __del->getSensors(xPos, yPos, ori, __ctx);
00313 }
00314 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00315 {
00316 __handleExceptionWrapper(__delBase, __ex, 0);
00317 }
00318 catch(const ::Ice::LocalException& __ex)
00319 {
00320 __handleException(__delBase, __ex, 0, __cnt);
00321 }
00322 }
00323 }
00324
00325 bool
00326 IceProxy::Robots::IRobot::getDistanceAngle(::Ice::Float& dist, ::Ice::Float& ang, const ::Ice::Context* __ctx)
00327 {
00328 int __cnt = 0;
00329 while(true)
00330 {
00331 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00332 try
00333 {
00334 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00335 IceUtil::DummyBCC dummy;
00336 #endif
00337 __checkTwowayOnly(__Robots__IRobot__getDistanceAngle_name);
00338 __delBase = __getDelegate(false);
00339 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00340 return __del->getDistanceAngle(dist, ang, __ctx);
00341 }
00342 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00343 {
00344 __handleExceptionWrapper(__delBase, __ex, 0);
00345 }
00346 catch(const ::Ice::LocalException& __ex)
00347 {
00348 __handleException(__delBase, __ex, 0, __cnt);
00349 }
00350 }
00351 }
00352
00353 void
00354 IceProxy::Robots::IRobot::motorsOff(::Ice::Short i, const ::Ice::Context* __ctx)
00355 {
00356 int __cnt = 0;
00357 while(true)
00358 {
00359 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00360 try
00361 {
00362 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00363 IceUtil::DummyBCC dummy;
00364 #endif
00365 __delBase = __getDelegate(false);
00366 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00367 __del->motorsOff(i, __ctx);
00368 return;
00369 }
00370 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00371 {
00372 __handleExceptionWrapper(__delBase, __ex, 0);
00373 }
00374 catch(const ::Ice::LocalException& __ex)
00375 {
00376 __handleException(__delBase, __ex, 0, __cnt);
00377 }
00378 }
00379 }
00380
00381 void
00382 IceProxy::Robots::IRobot::setMotor(::Ice::Short i, ::Ice::Float val, const ::Ice::Context* __ctx)
00383 {
00384 int __cnt = 0;
00385 while(true)
00386 {
00387 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00388 try
00389 {
00390 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00391 IceUtil::DummyBCC dummy;
00392 #endif
00393 __delBase = __getDelegate(false);
00394 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00395 __del->setMotor(i, val, __ctx);
00396 return;
00397 }
00398 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00399 {
00400 __handleExceptionWrapper(__delBase, __ex, 0);
00401 }
00402 catch(const ::Ice::LocalException& __ex)
00403 {
00404 __handleException(__delBase, __ex, 0, __cnt);
00405 }
00406 }
00407 }
00408
00409 ::Ice::Short
00410 IceProxy::Robots::IRobot::sendRawCmd(const ::std::string& data, const ::Ice::Context* __ctx)
00411 {
00412 int __cnt = 0;
00413 while(true)
00414 {
00415 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00416 try
00417 {
00418 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00419 IceUtil::DummyBCC dummy;
00420 #endif
00421 __checkTwowayOnly(__Robots__IRobot__sendRawCmd_name);
00422 __delBase = __getDelegate(false);
00423 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00424 return __del->sendRawCmd(data, __ctx);
00425 }
00426 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00427 {
00428 __handleExceptionWrapper(__delBase, __ex, 0);
00429 }
00430 catch(const ::Ice::LocalException& __ex)
00431 {
00432 __handleException(__delBase, __ex, 0, __cnt);
00433 }
00434 }
00435 }
00436
00437 void
00438 IceProxy::Robots::IRobot::playSong(::Ice::Short song, const ::Ice::Context* __ctx)
00439 {
00440 int __cnt = 0;
00441 while(true)
00442 {
00443 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00444 try
00445 {
00446 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00447 IceUtil::DummyBCC dummy;
00448 #endif
00449 __delBase = __getDelegate(false);
00450 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00451 __del->playSong(song, __ctx);
00452 return;
00453 }
00454 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00455 {
00456 __handleExceptionWrapper(__delBase, __ex, 0);
00457 }
00458 catch(const ::Ice::LocalException& __ex)
00459 {
00460 __handleException(__delBase, __ex, 0, __cnt);
00461 }
00462 }
00463 }
00464
00465 void
00466 IceProxy::Robots::IRobot::sendStart(const ::Ice::Context* __ctx)
00467 {
00468 int __cnt = 0;
00469 while(true)
00470 {
00471 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00472 try
00473 {
00474 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00475 IceUtil::DummyBCC dummy;
00476 #endif
00477 __delBase = __getDelegate(false);
00478 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00479 __del->sendStart(__ctx);
00480 return;
00481 }
00482 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00483 {
00484 __handleExceptionWrapper(__delBase, __ex, 0);
00485 }
00486 catch(const ::Ice::LocalException& __ex)
00487 {
00488 __handleException(__delBase, __ex, 0, __cnt);
00489 }
00490 }
00491 }
00492
00493 void
00494 IceProxy::Robots::IRobot::setMode(::Robots::IRobotModes mode, const ::Ice::Context* __ctx)
00495 {
00496 int __cnt = 0;
00497 while(true)
00498 {
00499 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00500 try
00501 {
00502 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00503 IceUtil::DummyBCC dummy;
00504 #endif
00505 __delBase = __getDelegate(false);
00506 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00507 __del->setMode(mode, __ctx);
00508 return;
00509 }
00510 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00511 {
00512 __handleExceptionWrapper(__delBase, __ex, 0);
00513 }
00514 catch(const ::Ice::LocalException& __ex)
00515 {
00516 __handleException(__delBase, __ex, 0, __cnt);
00517 }
00518 }
00519 }
00520
00521 void
00522 IceProxy::Robots::IRobot::setDemo(::Ice::Short demo, const ::Ice::Context* __ctx)
00523 {
00524 int __cnt = 0;
00525 while(true)
00526 {
00527 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00528 try
00529 {
00530 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00531 IceUtil::DummyBCC dummy;
00532 #endif
00533 __delBase = __getDelegate(false);
00534 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00535 __del->setDemo(demo, __ctx);
00536 return;
00537 }
00538 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00539 {
00540 __handleExceptionWrapper(__delBase, __ex, 0);
00541 }
00542 catch(const ::Ice::LocalException& __ex)
00543 {
00544 __handleException(__delBase, __ex, 0, __cnt);
00545 }
00546 }
00547 }
00548
00549 void
00550 IceProxy::Robots::IRobot::setLED(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Context* __ctx)
00551 {
00552 int __cnt = 0;
00553 while(true)
00554 {
00555 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00556 try
00557 {
00558 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00559 IceUtil::DummyBCC dummy;
00560 #endif
00561 __delBase = __getDelegate(false);
00562 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00563 __del->setLED(led, color, intensity, __ctx);
00564 return;
00565 }
00566 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00567 {
00568 __handleExceptionWrapper(__delBase, __ex, 0);
00569 }
00570 catch(const ::Ice::LocalException& __ex)
00571 {
00572 __handleException(__delBase, __ex, 0, __cnt);
00573 }
00574 }
00575 }
00576
00577 void
00578 IceProxy::Robots::IRobot::shutdown(const ::Ice::Context* __ctx)
00579 {
00580 int __cnt = 0;
00581 while(true)
00582 {
00583 ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00584 try
00585 {
00586 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00587 IceUtil::DummyBCC dummy;
00588 #endif
00589 __delBase = __getDelegate(false);
00590 ::IceDelegate::Robots::IRobot* __del = dynamic_cast< ::IceDelegate::Robots::IRobot*>(__delBase.get());
00591 __del->shutdown(__ctx);
00592 return;
00593 }
00594 catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00595 {
00596 __handleExceptionWrapper(__delBase, __ex, 0);
00597 }
00598 catch(const ::Ice::LocalException& __ex)
00599 {
00600 __handleException(__delBase, __ex, 0, __cnt);
00601 }
00602 }
00603 }
00604
00605 const ::std::string&
00606 IceProxy::Robots::IRobot::ice_staticId()
00607 {
00608 return ::Robots::IRobot::ice_staticId();
00609 }
00610
00611 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00612 IceProxy::Robots::IRobot::__createDelegateM()
00613 {
00614 return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::Robots::IRobot);
00615 }
00616
00617 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00618 IceProxy::Robots::IRobot::__createDelegateD()
00619 {
00620 return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::Robots::IRobot);
00621 }
00622
00623 ::IceProxy::Ice::Object*
00624 IceProxy::Robots::IRobot::__newInstance() const
00625 {
00626 return new IRobot;
00627 }
00628
00629 ::Ice::Float
00630 IceDelegateM::Robots::IRobot::getSpeed(const ::Ice::Context* __context)
00631 {
00632 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getSpeed_name, ::Ice::Normal, __context);
00633 bool __ok = __og.invoke();
00634 ::Ice::Float __ret;
00635 try
00636 {
00637 if(!__ok)
00638 {
00639 try
00640 {
00641 __og.throwUserException();
00642 }
00643 catch(const ::Ice::UserException& __ex)
00644 {
00645 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00646 throw __uue;
00647 }
00648 }
00649 ::IceInternal::BasicStream* __is = __og.is();
00650 __is->startReadEncaps();
00651 __is->read(__ret);
00652 __is->endReadEncaps();
00653 return __ret;
00654 }
00655 catch(const ::Ice::LocalException& __ex)
00656 {
00657 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00658 }
00659 }
00660
00661 ::Ice::Short
00662 IceDelegateM::Robots::IRobot::setSpeed(::Ice::Float speed, const ::Ice::Context* __context)
00663 {
00664 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__setSpeed_name, ::Ice::Normal, __context);
00665 try
00666 {
00667 ::IceInternal::BasicStream* __os = __og.os();
00668 __os->write(speed);
00669 }
00670 catch(const ::Ice::LocalException& __ex)
00671 {
00672 __og.abort(__ex);
00673 }
00674 bool __ok = __og.invoke();
00675 ::Ice::Short __ret;
00676 try
00677 {
00678 if(!__ok)
00679 {
00680 try
00681 {
00682 __og.throwUserException();
00683 }
00684 catch(const ::Ice::UserException& __ex)
00685 {
00686 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00687 throw __uue;
00688 }
00689 }
00690 ::IceInternal::BasicStream* __is = __og.is();
00691 __is->startReadEncaps();
00692 __is->read(__ret);
00693 __is->endReadEncaps();
00694 return __ret;
00695 }
00696 catch(const ::Ice::LocalException& __ex)
00697 {
00698 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00699 }
00700 }
00701
00702 ::Ice::Float
00703 IceDelegateM::Robots::IRobot::getSteering(const ::Ice::Context* __context)
00704 {
00705 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getSteering_name, ::Ice::Normal, __context);
00706 bool __ok = __og.invoke();
00707 ::Ice::Float __ret;
00708 try
00709 {
00710 if(!__ok)
00711 {
00712 try
00713 {
00714 __og.throwUserException();
00715 }
00716 catch(const ::Ice::UserException& __ex)
00717 {
00718 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00719 throw __uue;
00720 }
00721 }
00722 ::IceInternal::BasicStream* __is = __og.is();
00723 __is->startReadEncaps();
00724 __is->read(__ret);
00725 __is->endReadEncaps();
00726 return __ret;
00727 }
00728 catch(const ::Ice::LocalException& __ex)
00729 {
00730 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00731 }
00732 }
00733
00734 ::Ice::Short
00735 IceDelegateM::Robots::IRobot::setSteering(::Ice::Float steeringPos, const ::Ice::Context* __context)
00736 {
00737 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__setSteering_name, ::Ice::Normal, __context);
00738 try
00739 {
00740 ::IceInternal::BasicStream* __os = __og.os();
00741 __os->write(steeringPos);
00742 }
00743 catch(const ::Ice::LocalException& __ex)
00744 {
00745 __og.abort(__ex);
00746 }
00747 bool __ok = __og.invoke();
00748 ::Ice::Short __ret;
00749 try
00750 {
00751 if(!__ok)
00752 {
00753 try
00754 {
00755 __og.throwUserException();
00756 }
00757 catch(const ::Ice::UserException& __ex)
00758 {
00759 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00760 throw __uue;
00761 }
00762 }
00763 ::IceInternal::BasicStream* __is = __og.is();
00764 __is->startReadEncaps();
00765 __is->read(__ret);
00766 __is->endReadEncaps();
00767 return __ret;
00768 }
00769 catch(const ::Ice::LocalException& __ex)
00770 {
00771 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00772 }
00773 }
00774
00775 ::ImageIceMod::ImageIce
00776 IceDelegateM::Robots::IRobot::getImageSensor(::Ice::Short i, bool useColor, const ::Ice::Context* __context)
00777 {
00778 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getImageSensor_name, ::Ice::Normal, __context);
00779 try
00780 {
00781 ::IceInternal::BasicStream* __os = __og.os();
00782 __os->write(i);
00783 __os->write(useColor);
00784 }
00785 catch(const ::Ice::LocalException& __ex)
00786 {
00787 __og.abort(__ex);
00788 }
00789 bool __ok = __og.invoke();
00790 ::ImageIceMod::ImageIce __ret;
00791 try
00792 {
00793 if(!__ok)
00794 {
00795 try
00796 {
00797 __og.throwUserException();
00798 }
00799 catch(const ::Ice::UserException& __ex)
00800 {
00801 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00802 throw __uue;
00803 }
00804 }
00805 ::IceInternal::BasicStream* __is = __og.is();
00806 __is->startReadEncaps();
00807 __ret.__read(__is);
00808 __is->endReadEncaps();
00809 return __ret;
00810 }
00811 catch(const ::Ice::LocalException& __ex)
00812 {
00813 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00814 }
00815 }
00816
00817 ::ImageIceMod::DimsIce
00818 IceDelegateM::Robots::IRobot::getImageSensorDims(::Ice::Short i, const ::Ice::Context* __context)
00819 {
00820 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getImageSensorDims_name, ::Ice::Normal, __context);
00821 try
00822 {
00823 ::IceInternal::BasicStream* __os = __og.os();
00824 __os->write(i);
00825 }
00826 catch(const ::Ice::LocalException& __ex)
00827 {
00828 __og.abort(__ex);
00829 }
00830 bool __ok = __og.invoke();
00831 ::ImageIceMod::DimsIce __ret;
00832 try
00833 {
00834 if(!__ok)
00835 {
00836 try
00837 {
00838 __og.throwUserException();
00839 }
00840 catch(const ::Ice::UserException& __ex)
00841 {
00842 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00843 throw __uue;
00844 }
00845 }
00846 ::IceInternal::BasicStream* __is = __og.is();
00847 __is->startReadEncaps();
00848 __ret.__read(__is);
00849 __is->endReadEncaps();
00850 return __ret;
00851 }
00852 catch(const ::Ice::LocalException& __ex)
00853 {
00854 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00855 }
00856 }
00857
00858 ::Ice::Float
00859 IceDelegateM::Robots::IRobot::getSensorValue(::Ice::Short i, const ::Ice::Context* __context)
00860 {
00861 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getSensorValue_name, ::Ice::Normal, __context);
00862 try
00863 {
00864 ::IceInternal::BasicStream* __os = __og.os();
00865 __os->write(i);
00866 }
00867 catch(const ::Ice::LocalException& __ex)
00868 {
00869 __og.abort(__ex);
00870 }
00871 bool __ok = __og.invoke();
00872 ::Ice::Float __ret;
00873 try
00874 {
00875 if(!__ok)
00876 {
00877 try
00878 {
00879 __og.throwUserException();
00880 }
00881 catch(const ::Ice::UserException& __ex)
00882 {
00883 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00884 throw __uue;
00885 }
00886 }
00887 ::IceInternal::BasicStream* __is = __og.is();
00888 __is->startReadEncaps();
00889 __is->read(__ret);
00890 __is->endReadEncaps();
00891 return __ret;
00892 }
00893 catch(const ::Ice::LocalException& __ex)
00894 {
00895 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00896 }
00897 }
00898
00899 bool
00900 IceDelegateM::Robots::IRobot::getSensors(::Ice::Float& xPos, ::Ice::Float& yPos, ::Ice::Float& ori, const ::Ice::Context* __context)
00901 {
00902 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getSensors_name, ::Ice::Normal, __context);
00903 bool __ok = __og.invoke();
00904 bool __ret;
00905 try
00906 {
00907 if(!__ok)
00908 {
00909 try
00910 {
00911 __og.throwUserException();
00912 }
00913 catch(const ::Ice::UserException& __ex)
00914 {
00915 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00916 throw __uue;
00917 }
00918 }
00919 ::IceInternal::BasicStream* __is = __og.is();
00920 __is->startReadEncaps();
00921 __is->read(xPos);
00922 __is->read(yPos);
00923 __is->read(ori);
00924 __is->read(__ret);
00925 __is->endReadEncaps();
00926 return __ret;
00927 }
00928 catch(const ::Ice::LocalException& __ex)
00929 {
00930 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00931 }
00932 }
00933
00934 bool
00935 IceDelegateM::Robots::IRobot::getDistanceAngle(::Ice::Float& dist, ::Ice::Float& ang, const ::Ice::Context* __context)
00936 {
00937 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__getDistanceAngle_name, ::Ice::Normal, __context);
00938 bool __ok = __og.invoke();
00939 bool __ret;
00940 try
00941 {
00942 if(!__ok)
00943 {
00944 try
00945 {
00946 __og.throwUserException();
00947 }
00948 catch(const ::Ice::UserException& __ex)
00949 {
00950 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00951 throw __uue;
00952 }
00953 }
00954 ::IceInternal::BasicStream* __is = __og.is();
00955 __is->startReadEncaps();
00956 __is->read(dist);
00957 __is->read(ang);
00958 __is->read(__ret);
00959 __is->endReadEncaps();
00960 return __ret;
00961 }
00962 catch(const ::Ice::LocalException& __ex)
00963 {
00964 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00965 }
00966 }
00967
00968 void
00969 IceDelegateM::Robots::IRobot::motorsOff(::Ice::Short i, const ::Ice::Context* __context)
00970 {
00971 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__motorsOff_name, ::Ice::Normal, __context);
00972 try
00973 {
00974 ::IceInternal::BasicStream* __os = __og.os();
00975 __os->write(i);
00976 }
00977 catch(const ::Ice::LocalException& __ex)
00978 {
00979 __og.abort(__ex);
00980 }
00981 bool __ok = __og.invoke();
00982 if(!__og.is()->b.empty())
00983 {
00984 try
00985 {
00986 if(!__ok)
00987 {
00988 try
00989 {
00990 __og.throwUserException();
00991 }
00992 catch(const ::Ice::UserException& __ex)
00993 {
00994 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00995 throw __uue;
00996 }
00997 }
00998 __og.is()->skipEmptyEncaps();
00999 }
01000 catch(const ::Ice::LocalException& __ex)
01001 {
01002 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01003 }
01004 }
01005 }
01006
01007 void
01008 IceDelegateM::Robots::IRobot::setMotor(::Ice::Short i, ::Ice::Float val, const ::Ice::Context* __context)
01009 {
01010 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__setMotor_name, ::Ice::Normal, __context);
01011 try
01012 {
01013 ::IceInternal::BasicStream* __os = __og.os();
01014 __os->write(i);
01015 __os->write(val);
01016 }
01017 catch(const ::Ice::LocalException& __ex)
01018 {
01019 __og.abort(__ex);
01020 }
01021 bool __ok = __og.invoke();
01022 if(!__og.is()->b.empty())
01023 {
01024 try
01025 {
01026 if(!__ok)
01027 {
01028 try
01029 {
01030 __og.throwUserException();
01031 }
01032 catch(const ::Ice::UserException& __ex)
01033 {
01034 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01035 throw __uue;
01036 }
01037 }
01038 __og.is()->skipEmptyEncaps();
01039 }
01040 catch(const ::Ice::LocalException& __ex)
01041 {
01042 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01043 }
01044 }
01045 }
01046
01047 ::Ice::Short
01048 IceDelegateM::Robots::IRobot::sendRawCmd(const ::std::string& data, const ::Ice::Context* __context)
01049 {
01050 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__sendRawCmd_name, ::Ice::Normal, __context);
01051 try
01052 {
01053 ::IceInternal::BasicStream* __os = __og.os();
01054 __os->write(data);
01055 }
01056 catch(const ::Ice::LocalException& __ex)
01057 {
01058 __og.abort(__ex);
01059 }
01060 bool __ok = __og.invoke();
01061 ::Ice::Short __ret;
01062 try
01063 {
01064 if(!__ok)
01065 {
01066 try
01067 {
01068 __og.throwUserException();
01069 }
01070 catch(const ::Ice::UserException& __ex)
01071 {
01072 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01073 throw __uue;
01074 }
01075 }
01076 ::IceInternal::BasicStream* __is = __og.is();
01077 __is->startReadEncaps();
01078 __is->read(__ret);
01079 __is->endReadEncaps();
01080 return __ret;
01081 }
01082 catch(const ::Ice::LocalException& __ex)
01083 {
01084 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01085 }
01086 }
01087
01088 void
01089 IceDelegateM::Robots::IRobot::playSong(::Ice::Short song, const ::Ice::Context* __context)
01090 {
01091 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__playSong_name, ::Ice::Normal, __context);
01092 try
01093 {
01094 ::IceInternal::BasicStream* __os = __og.os();
01095 __os->write(song);
01096 }
01097 catch(const ::Ice::LocalException& __ex)
01098 {
01099 __og.abort(__ex);
01100 }
01101 bool __ok = __og.invoke();
01102 if(!__og.is()->b.empty())
01103 {
01104 try
01105 {
01106 if(!__ok)
01107 {
01108 try
01109 {
01110 __og.throwUserException();
01111 }
01112 catch(const ::Ice::UserException& __ex)
01113 {
01114 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01115 throw __uue;
01116 }
01117 }
01118 __og.is()->skipEmptyEncaps();
01119 }
01120 catch(const ::Ice::LocalException& __ex)
01121 {
01122 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01123 }
01124 }
01125 }
01126
01127 void
01128 IceDelegateM::Robots::IRobot::sendStart(const ::Ice::Context* __context)
01129 {
01130 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__sendStart_name, ::Ice::Normal, __context);
01131 bool __ok = __og.invoke();
01132 if(!__og.is()->b.empty())
01133 {
01134 try
01135 {
01136 if(!__ok)
01137 {
01138 try
01139 {
01140 __og.throwUserException();
01141 }
01142 catch(const ::Ice::UserException& __ex)
01143 {
01144 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01145 throw __uue;
01146 }
01147 }
01148 __og.is()->skipEmptyEncaps();
01149 }
01150 catch(const ::Ice::LocalException& __ex)
01151 {
01152 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01153 }
01154 }
01155 }
01156
01157 void
01158 IceDelegateM::Robots::IRobot::setMode(::Robots::IRobotModes mode, const ::Ice::Context* __context)
01159 {
01160 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__setMode_name, ::Ice::Normal, __context);
01161 try
01162 {
01163 ::IceInternal::BasicStream* __os = __og.os();
01164 ::Robots::__write(__os, mode);
01165 }
01166 catch(const ::Ice::LocalException& __ex)
01167 {
01168 __og.abort(__ex);
01169 }
01170 bool __ok = __og.invoke();
01171 if(!__og.is()->b.empty())
01172 {
01173 try
01174 {
01175 if(!__ok)
01176 {
01177 try
01178 {
01179 __og.throwUserException();
01180 }
01181 catch(const ::Ice::UserException& __ex)
01182 {
01183 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01184 throw __uue;
01185 }
01186 }
01187 __og.is()->skipEmptyEncaps();
01188 }
01189 catch(const ::Ice::LocalException& __ex)
01190 {
01191 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01192 }
01193 }
01194 }
01195
01196 void
01197 IceDelegateM::Robots::IRobot::setDemo(::Ice::Short demo, const ::Ice::Context* __context)
01198 {
01199 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__setDemo_name, ::Ice::Normal, __context);
01200 try
01201 {
01202 ::IceInternal::BasicStream* __os = __og.os();
01203 __os->write(demo);
01204 }
01205 catch(const ::Ice::LocalException& __ex)
01206 {
01207 __og.abort(__ex);
01208 }
01209 bool __ok = __og.invoke();
01210 if(!__og.is()->b.empty())
01211 {
01212 try
01213 {
01214 if(!__ok)
01215 {
01216 try
01217 {
01218 __og.throwUserException();
01219 }
01220 catch(const ::Ice::UserException& __ex)
01221 {
01222 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01223 throw __uue;
01224 }
01225 }
01226 __og.is()->skipEmptyEncaps();
01227 }
01228 catch(const ::Ice::LocalException& __ex)
01229 {
01230 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01231 }
01232 }
01233 }
01234
01235 void
01236 IceDelegateM::Robots::IRobot::setLED(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Context* __context)
01237 {
01238 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__setLED_name, ::Ice::Normal, __context);
01239 try
01240 {
01241 ::IceInternal::BasicStream* __os = __og.os();
01242 __os->write(led);
01243 __os->write(color);
01244 __os->write(intensity);
01245 }
01246 catch(const ::Ice::LocalException& __ex)
01247 {
01248 __og.abort(__ex);
01249 }
01250 bool __ok = __og.invoke();
01251 if(!__og.is()->b.empty())
01252 {
01253 try
01254 {
01255 if(!__ok)
01256 {
01257 try
01258 {
01259 __og.throwUserException();
01260 }
01261 catch(const ::Ice::UserException& __ex)
01262 {
01263 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01264 throw __uue;
01265 }
01266 }
01267 __og.is()->skipEmptyEncaps();
01268 }
01269 catch(const ::Ice::LocalException& __ex)
01270 {
01271 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01272 }
01273 }
01274 }
01275
01276 void
01277 IceDelegateM::Robots::IRobot::shutdown(const ::Ice::Context* __context)
01278 {
01279 ::IceInternal::Outgoing __og(__handler.get(), __Robots__IRobot__shutdown_name, ::Ice::Normal, __context);
01280 bool __ok = __og.invoke();
01281 if(!__og.is()->b.empty())
01282 {
01283 try
01284 {
01285 if(!__ok)
01286 {
01287 try
01288 {
01289 __og.throwUserException();
01290 }
01291 catch(const ::Ice::UserException& __ex)
01292 {
01293 ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
01294 throw __uue;
01295 }
01296 }
01297 __og.is()->skipEmptyEncaps();
01298 }
01299 catch(const ::Ice::LocalException& __ex)
01300 {
01301 throw ::IceInternal::LocalExceptionWrapper(__ex, false);
01302 }
01303 }
01304 }
01305
01306 ::Ice::Float
01307 IceDelegateD::Robots::IRobot::getSpeed(const ::Ice::Context* __context)
01308 {
01309 class _DirectI : public ::IceInternal::Direct
01310 {
01311 public:
01312
01313 _DirectI(::Ice::Float& __result, const ::Ice::Current& __current) :
01314 ::IceInternal::Direct(__current),
01315 _result(__result)
01316 {
01317 }
01318
01319 virtual ::Ice::DispatchStatus
01320 run(::Ice::Object* object)
01321 {
01322 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01323 if(!servant)
01324 {
01325 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01326 }
01327 _result = servant->getSpeed(_current);
01328 return ::Ice::DispatchOK;
01329 }
01330
01331 private:
01332
01333 ::Ice::Float& _result;
01334 };
01335
01336 ::Ice::Current __current;
01337 __initCurrent(__current, __Robots__IRobot__getSpeed_name, ::Ice::Normal, __context);
01338 ::Ice::Float __result;
01339 try
01340 {
01341 _DirectI __direct(__result, __current);
01342 try
01343 {
01344 __direct.servant()->__collocDispatch(__direct);
01345 }
01346 catch(...)
01347 {
01348 __direct.destroy();
01349 throw;
01350 }
01351 __direct.destroy();
01352 }
01353 catch(const ::Ice::SystemException&)
01354 {
01355 throw;
01356 }
01357 catch(const ::IceInternal::LocalExceptionWrapper&)
01358 {
01359 throw;
01360 }
01361 catch(const ::std::exception& __ex)
01362 {
01363 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01364 }
01365 catch(...)
01366 {
01367 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01368 }
01369 return __result;
01370 }
01371
01372 ::Ice::Short
01373 IceDelegateD::Robots::IRobot::setSpeed(::Ice::Float speed, const ::Ice::Context* __context)
01374 {
01375 class _DirectI : public ::IceInternal::Direct
01376 {
01377 public:
01378
01379 _DirectI(::Ice::Short& __result, ::Ice::Float speed, const ::Ice::Current& __current) :
01380 ::IceInternal::Direct(__current),
01381 _result(__result),
01382 _m_speed(speed)
01383 {
01384 }
01385
01386 virtual ::Ice::DispatchStatus
01387 run(::Ice::Object* object)
01388 {
01389 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01390 if(!servant)
01391 {
01392 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01393 }
01394 _result = servant->setSpeed(_m_speed, _current);
01395 return ::Ice::DispatchOK;
01396 }
01397
01398 private:
01399
01400 ::Ice::Short& _result;
01401 ::Ice::Float _m_speed;
01402 };
01403
01404 ::Ice::Current __current;
01405 __initCurrent(__current, __Robots__IRobot__setSpeed_name, ::Ice::Normal, __context);
01406 ::Ice::Short __result;
01407 try
01408 {
01409 _DirectI __direct(__result, speed, __current);
01410 try
01411 {
01412 __direct.servant()->__collocDispatch(__direct);
01413 }
01414 catch(...)
01415 {
01416 __direct.destroy();
01417 throw;
01418 }
01419 __direct.destroy();
01420 }
01421 catch(const ::Ice::SystemException&)
01422 {
01423 throw;
01424 }
01425 catch(const ::IceInternal::LocalExceptionWrapper&)
01426 {
01427 throw;
01428 }
01429 catch(const ::std::exception& __ex)
01430 {
01431 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01432 }
01433 catch(...)
01434 {
01435 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01436 }
01437 return __result;
01438 }
01439
01440 ::Ice::Float
01441 IceDelegateD::Robots::IRobot::getSteering(const ::Ice::Context* __context)
01442 {
01443 class _DirectI : public ::IceInternal::Direct
01444 {
01445 public:
01446
01447 _DirectI(::Ice::Float& __result, const ::Ice::Current& __current) :
01448 ::IceInternal::Direct(__current),
01449 _result(__result)
01450 {
01451 }
01452
01453 virtual ::Ice::DispatchStatus
01454 run(::Ice::Object* object)
01455 {
01456 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01457 if(!servant)
01458 {
01459 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01460 }
01461 _result = servant->getSteering(_current);
01462 return ::Ice::DispatchOK;
01463 }
01464
01465 private:
01466
01467 ::Ice::Float& _result;
01468 };
01469
01470 ::Ice::Current __current;
01471 __initCurrent(__current, __Robots__IRobot__getSteering_name, ::Ice::Normal, __context);
01472 ::Ice::Float __result;
01473 try
01474 {
01475 _DirectI __direct(__result, __current);
01476 try
01477 {
01478 __direct.servant()->__collocDispatch(__direct);
01479 }
01480 catch(...)
01481 {
01482 __direct.destroy();
01483 throw;
01484 }
01485 __direct.destroy();
01486 }
01487 catch(const ::Ice::SystemException&)
01488 {
01489 throw;
01490 }
01491 catch(const ::IceInternal::LocalExceptionWrapper&)
01492 {
01493 throw;
01494 }
01495 catch(const ::std::exception& __ex)
01496 {
01497 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01498 }
01499 catch(...)
01500 {
01501 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01502 }
01503 return __result;
01504 }
01505
01506 ::Ice::Short
01507 IceDelegateD::Robots::IRobot::setSteering(::Ice::Float steeringPos, const ::Ice::Context* __context)
01508 {
01509 class _DirectI : public ::IceInternal::Direct
01510 {
01511 public:
01512
01513 _DirectI(::Ice::Short& __result, ::Ice::Float steeringPos, const ::Ice::Current& __current) :
01514 ::IceInternal::Direct(__current),
01515 _result(__result),
01516 _m_steeringPos(steeringPos)
01517 {
01518 }
01519
01520 virtual ::Ice::DispatchStatus
01521 run(::Ice::Object* object)
01522 {
01523 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01524 if(!servant)
01525 {
01526 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01527 }
01528 _result = servant->setSteering(_m_steeringPos, _current);
01529 return ::Ice::DispatchOK;
01530 }
01531
01532 private:
01533
01534 ::Ice::Short& _result;
01535 ::Ice::Float _m_steeringPos;
01536 };
01537
01538 ::Ice::Current __current;
01539 __initCurrent(__current, __Robots__IRobot__setSteering_name, ::Ice::Normal, __context);
01540 ::Ice::Short __result;
01541 try
01542 {
01543 _DirectI __direct(__result, steeringPos, __current);
01544 try
01545 {
01546 __direct.servant()->__collocDispatch(__direct);
01547 }
01548 catch(...)
01549 {
01550 __direct.destroy();
01551 throw;
01552 }
01553 __direct.destroy();
01554 }
01555 catch(const ::Ice::SystemException&)
01556 {
01557 throw;
01558 }
01559 catch(const ::IceInternal::LocalExceptionWrapper&)
01560 {
01561 throw;
01562 }
01563 catch(const ::std::exception& __ex)
01564 {
01565 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01566 }
01567 catch(...)
01568 {
01569 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01570 }
01571 return __result;
01572 }
01573
01574 ::ImageIceMod::ImageIce
01575 IceDelegateD::Robots::IRobot::getImageSensor(::Ice::Short i, bool useColor, const ::Ice::Context* __context)
01576 {
01577 class _DirectI : public ::IceInternal::Direct
01578 {
01579 public:
01580
01581 _DirectI(::ImageIceMod::ImageIce& __result, ::Ice::Short i, bool useColor, const ::Ice::Current& __current) :
01582 ::IceInternal::Direct(__current),
01583 _result(__result),
01584 _m_i(i),
01585 _m_useColor(useColor)
01586 {
01587 }
01588
01589 virtual ::Ice::DispatchStatus
01590 run(::Ice::Object* object)
01591 {
01592 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01593 if(!servant)
01594 {
01595 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01596 }
01597 _result = servant->getImageSensor(_m_i, _m_useColor, _current);
01598 return ::Ice::DispatchOK;
01599 }
01600
01601 private:
01602
01603 ::ImageIceMod::ImageIce& _result;
01604 ::Ice::Short _m_i;
01605 bool _m_useColor;
01606 };
01607
01608 ::Ice::Current __current;
01609 __initCurrent(__current, __Robots__IRobot__getImageSensor_name, ::Ice::Normal, __context);
01610 ::ImageIceMod::ImageIce __result;
01611 try
01612 {
01613 _DirectI __direct(__result, i, useColor, __current);
01614 try
01615 {
01616 __direct.servant()->__collocDispatch(__direct);
01617 }
01618 catch(...)
01619 {
01620 __direct.destroy();
01621 throw;
01622 }
01623 __direct.destroy();
01624 }
01625 catch(const ::Ice::SystemException&)
01626 {
01627 throw;
01628 }
01629 catch(const ::IceInternal::LocalExceptionWrapper&)
01630 {
01631 throw;
01632 }
01633 catch(const ::std::exception& __ex)
01634 {
01635 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01636 }
01637 catch(...)
01638 {
01639 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01640 }
01641 return __result;
01642 }
01643
01644 ::ImageIceMod::DimsIce
01645 IceDelegateD::Robots::IRobot::getImageSensorDims(::Ice::Short i, const ::Ice::Context* __context)
01646 {
01647 class _DirectI : public ::IceInternal::Direct
01648 {
01649 public:
01650
01651 _DirectI(::ImageIceMod::DimsIce& __result, ::Ice::Short i, const ::Ice::Current& __current) :
01652 ::IceInternal::Direct(__current),
01653 _result(__result),
01654 _m_i(i)
01655 {
01656 }
01657
01658 virtual ::Ice::DispatchStatus
01659 run(::Ice::Object* object)
01660 {
01661 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01662 if(!servant)
01663 {
01664 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01665 }
01666 _result = servant->getImageSensorDims(_m_i, _current);
01667 return ::Ice::DispatchOK;
01668 }
01669
01670 private:
01671
01672 ::ImageIceMod::DimsIce& _result;
01673 ::Ice::Short _m_i;
01674 };
01675
01676 ::Ice::Current __current;
01677 __initCurrent(__current, __Robots__IRobot__getImageSensorDims_name, ::Ice::Normal, __context);
01678 ::ImageIceMod::DimsIce __result;
01679 try
01680 {
01681 _DirectI __direct(__result, i, __current);
01682 try
01683 {
01684 __direct.servant()->__collocDispatch(__direct);
01685 }
01686 catch(...)
01687 {
01688 __direct.destroy();
01689 throw;
01690 }
01691 __direct.destroy();
01692 }
01693 catch(const ::Ice::SystemException&)
01694 {
01695 throw;
01696 }
01697 catch(const ::IceInternal::LocalExceptionWrapper&)
01698 {
01699 throw;
01700 }
01701 catch(const ::std::exception& __ex)
01702 {
01703 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01704 }
01705 catch(...)
01706 {
01707 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01708 }
01709 return __result;
01710 }
01711
01712 ::Ice::Float
01713 IceDelegateD::Robots::IRobot::getSensorValue(::Ice::Short i, const ::Ice::Context* __context)
01714 {
01715 class _DirectI : public ::IceInternal::Direct
01716 {
01717 public:
01718
01719 _DirectI(::Ice::Float& __result, ::Ice::Short i, const ::Ice::Current& __current) :
01720 ::IceInternal::Direct(__current),
01721 _result(__result),
01722 _m_i(i)
01723 {
01724 }
01725
01726 virtual ::Ice::DispatchStatus
01727 run(::Ice::Object* object)
01728 {
01729 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01730 if(!servant)
01731 {
01732 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01733 }
01734 _result = servant->getSensorValue(_m_i, _current);
01735 return ::Ice::DispatchOK;
01736 }
01737
01738 private:
01739
01740 ::Ice::Float& _result;
01741 ::Ice::Short _m_i;
01742 };
01743
01744 ::Ice::Current __current;
01745 __initCurrent(__current, __Robots__IRobot__getSensorValue_name, ::Ice::Normal, __context);
01746 ::Ice::Float __result;
01747 try
01748 {
01749 _DirectI __direct(__result, i, __current);
01750 try
01751 {
01752 __direct.servant()->__collocDispatch(__direct);
01753 }
01754 catch(...)
01755 {
01756 __direct.destroy();
01757 throw;
01758 }
01759 __direct.destroy();
01760 }
01761 catch(const ::Ice::SystemException&)
01762 {
01763 throw;
01764 }
01765 catch(const ::IceInternal::LocalExceptionWrapper&)
01766 {
01767 throw;
01768 }
01769 catch(const ::std::exception& __ex)
01770 {
01771 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01772 }
01773 catch(...)
01774 {
01775 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01776 }
01777 return __result;
01778 }
01779
01780 bool
01781 IceDelegateD::Robots::IRobot::getSensors(::Ice::Float& xPos, ::Ice::Float& yPos, ::Ice::Float& ori, const ::Ice::Context* __context)
01782 {
01783 class _DirectI : public ::IceInternal::Direct
01784 {
01785 public:
01786
01787 _DirectI(bool& __result, ::Ice::Float& xPos, ::Ice::Float& yPos, ::Ice::Float& ori, const ::Ice::Current& __current) :
01788 ::IceInternal::Direct(__current),
01789 _result(__result),
01790 _m_xPos(xPos),
01791 _m_yPos(yPos),
01792 _m_ori(ori)
01793 {
01794 }
01795
01796 virtual ::Ice::DispatchStatus
01797 run(::Ice::Object* object)
01798 {
01799 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01800 if(!servant)
01801 {
01802 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01803 }
01804 _result = servant->getSensors(_m_xPos, _m_yPos, _m_ori, _current);
01805 return ::Ice::DispatchOK;
01806 }
01807
01808 private:
01809
01810 bool& _result;
01811 ::Ice::Float& _m_xPos;
01812 ::Ice::Float& _m_yPos;
01813 ::Ice::Float& _m_ori;
01814 };
01815
01816 ::Ice::Current __current;
01817 __initCurrent(__current, __Robots__IRobot__getSensors_name, ::Ice::Normal, __context);
01818 bool __result;
01819 try
01820 {
01821 _DirectI __direct(__result, xPos, yPos, ori, __current);
01822 try
01823 {
01824 __direct.servant()->__collocDispatch(__direct);
01825 }
01826 catch(...)
01827 {
01828 __direct.destroy();
01829 throw;
01830 }
01831 __direct.destroy();
01832 }
01833 catch(const ::Ice::SystemException&)
01834 {
01835 throw;
01836 }
01837 catch(const ::IceInternal::LocalExceptionWrapper&)
01838 {
01839 throw;
01840 }
01841 catch(const ::std::exception& __ex)
01842 {
01843 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01844 }
01845 catch(...)
01846 {
01847 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01848 }
01849 return __result;
01850 }
01851
01852 bool
01853 IceDelegateD::Robots::IRobot::getDistanceAngle(::Ice::Float& dist, ::Ice::Float& ang, const ::Ice::Context* __context)
01854 {
01855 class _DirectI : public ::IceInternal::Direct
01856 {
01857 public:
01858
01859 _DirectI(bool& __result, ::Ice::Float& dist, ::Ice::Float& ang, const ::Ice::Current& __current) :
01860 ::IceInternal::Direct(__current),
01861 _result(__result),
01862 _m_dist(dist),
01863 _m_ang(ang)
01864 {
01865 }
01866
01867 virtual ::Ice::DispatchStatus
01868 run(::Ice::Object* object)
01869 {
01870 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01871 if(!servant)
01872 {
01873 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01874 }
01875 _result = servant->getDistanceAngle(_m_dist, _m_ang, _current);
01876 return ::Ice::DispatchOK;
01877 }
01878
01879 private:
01880
01881 bool& _result;
01882 ::Ice::Float& _m_dist;
01883 ::Ice::Float& _m_ang;
01884 };
01885
01886 ::Ice::Current __current;
01887 __initCurrent(__current, __Robots__IRobot__getDistanceAngle_name, ::Ice::Normal, __context);
01888 bool __result;
01889 try
01890 {
01891 _DirectI __direct(__result, dist, ang, __current);
01892 try
01893 {
01894 __direct.servant()->__collocDispatch(__direct);
01895 }
01896 catch(...)
01897 {
01898 __direct.destroy();
01899 throw;
01900 }
01901 __direct.destroy();
01902 }
01903 catch(const ::Ice::SystemException&)
01904 {
01905 throw;
01906 }
01907 catch(const ::IceInternal::LocalExceptionWrapper&)
01908 {
01909 throw;
01910 }
01911 catch(const ::std::exception& __ex)
01912 {
01913 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01914 }
01915 catch(...)
01916 {
01917 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01918 }
01919 return __result;
01920 }
01921
01922 void
01923 IceDelegateD::Robots::IRobot::motorsOff(::Ice::Short i, const ::Ice::Context* __context)
01924 {
01925 class _DirectI : public ::IceInternal::Direct
01926 {
01927 public:
01928
01929 _DirectI(::Ice::Short i, const ::Ice::Current& __current) :
01930 ::IceInternal::Direct(__current),
01931 _m_i(i)
01932 {
01933 }
01934
01935 virtual ::Ice::DispatchStatus
01936 run(::Ice::Object* object)
01937 {
01938 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
01939 if(!servant)
01940 {
01941 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
01942 }
01943 servant->motorsOff(_m_i, _current);
01944 return ::Ice::DispatchOK;
01945 }
01946
01947 private:
01948
01949 ::Ice::Short _m_i;
01950 };
01951
01952 ::Ice::Current __current;
01953 __initCurrent(__current, __Robots__IRobot__motorsOff_name, ::Ice::Normal, __context);
01954 try
01955 {
01956 _DirectI __direct(i, __current);
01957 try
01958 {
01959 __direct.servant()->__collocDispatch(__direct);
01960 }
01961 catch(...)
01962 {
01963 __direct.destroy();
01964 throw;
01965 }
01966 __direct.destroy();
01967 }
01968 catch(const ::Ice::SystemException&)
01969 {
01970 throw;
01971 }
01972 catch(const ::IceInternal::LocalExceptionWrapper&)
01973 {
01974 throw;
01975 }
01976 catch(const ::std::exception& __ex)
01977 {
01978 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
01979 }
01980 catch(...)
01981 {
01982 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
01983 }
01984 }
01985
01986 void
01987 IceDelegateD::Robots::IRobot::setMotor(::Ice::Short i, ::Ice::Float val, const ::Ice::Context* __context)
01988 {
01989 class _DirectI : public ::IceInternal::Direct
01990 {
01991 public:
01992
01993 _DirectI(::Ice::Short i, ::Ice::Float val, const ::Ice::Current& __current) :
01994 ::IceInternal::Direct(__current),
01995 _m_i(i),
01996 _m_val(val)
01997 {
01998 }
01999
02000 virtual ::Ice::DispatchStatus
02001 run(::Ice::Object* object)
02002 {
02003 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02004 if(!servant)
02005 {
02006 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02007 }
02008 servant->setMotor(_m_i, _m_val, _current);
02009 return ::Ice::DispatchOK;
02010 }
02011
02012 private:
02013
02014 ::Ice::Short _m_i;
02015 ::Ice::Float _m_val;
02016 };
02017
02018 ::Ice::Current __current;
02019 __initCurrent(__current, __Robots__IRobot__setMotor_name, ::Ice::Normal, __context);
02020 try
02021 {
02022 _DirectI __direct(i, val, __current);
02023 try
02024 {
02025 __direct.servant()->__collocDispatch(__direct);
02026 }
02027 catch(...)
02028 {
02029 __direct.destroy();
02030 throw;
02031 }
02032 __direct.destroy();
02033 }
02034 catch(const ::Ice::SystemException&)
02035 {
02036 throw;
02037 }
02038 catch(const ::IceInternal::LocalExceptionWrapper&)
02039 {
02040 throw;
02041 }
02042 catch(const ::std::exception& __ex)
02043 {
02044 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02045 }
02046 catch(...)
02047 {
02048 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02049 }
02050 }
02051
02052 ::Ice::Short
02053 IceDelegateD::Robots::IRobot::sendRawCmd(const ::std::string& data, const ::Ice::Context* __context)
02054 {
02055 class _DirectI : public ::IceInternal::Direct
02056 {
02057 public:
02058
02059 _DirectI(::Ice::Short& __result, const ::std::string& data, const ::Ice::Current& __current) :
02060 ::IceInternal::Direct(__current),
02061 _result(__result),
02062 _m_data(data)
02063 {
02064 }
02065
02066 virtual ::Ice::DispatchStatus
02067 run(::Ice::Object* object)
02068 {
02069 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02070 if(!servant)
02071 {
02072 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02073 }
02074 _result = servant->sendRawCmd(_m_data, _current);
02075 return ::Ice::DispatchOK;
02076 }
02077
02078 private:
02079
02080 ::Ice::Short& _result;
02081 const ::std::string& _m_data;
02082 };
02083
02084 ::Ice::Current __current;
02085 __initCurrent(__current, __Robots__IRobot__sendRawCmd_name, ::Ice::Normal, __context);
02086 ::Ice::Short __result;
02087 try
02088 {
02089 _DirectI __direct(__result, data, __current);
02090 try
02091 {
02092 __direct.servant()->__collocDispatch(__direct);
02093 }
02094 catch(...)
02095 {
02096 __direct.destroy();
02097 throw;
02098 }
02099 __direct.destroy();
02100 }
02101 catch(const ::Ice::SystemException&)
02102 {
02103 throw;
02104 }
02105 catch(const ::IceInternal::LocalExceptionWrapper&)
02106 {
02107 throw;
02108 }
02109 catch(const ::std::exception& __ex)
02110 {
02111 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02112 }
02113 catch(...)
02114 {
02115 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02116 }
02117 return __result;
02118 }
02119
02120 void
02121 IceDelegateD::Robots::IRobot::playSong(::Ice::Short song, const ::Ice::Context* __context)
02122 {
02123 class _DirectI : public ::IceInternal::Direct
02124 {
02125 public:
02126
02127 _DirectI(::Ice::Short song, const ::Ice::Current& __current) :
02128 ::IceInternal::Direct(__current),
02129 _m_song(song)
02130 {
02131 }
02132
02133 virtual ::Ice::DispatchStatus
02134 run(::Ice::Object* object)
02135 {
02136 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02137 if(!servant)
02138 {
02139 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02140 }
02141 servant->playSong(_m_song, _current);
02142 return ::Ice::DispatchOK;
02143 }
02144
02145 private:
02146
02147 ::Ice::Short _m_song;
02148 };
02149
02150 ::Ice::Current __current;
02151 __initCurrent(__current, __Robots__IRobot__playSong_name, ::Ice::Normal, __context);
02152 try
02153 {
02154 _DirectI __direct(song, __current);
02155 try
02156 {
02157 __direct.servant()->__collocDispatch(__direct);
02158 }
02159 catch(...)
02160 {
02161 __direct.destroy();
02162 throw;
02163 }
02164 __direct.destroy();
02165 }
02166 catch(const ::Ice::SystemException&)
02167 {
02168 throw;
02169 }
02170 catch(const ::IceInternal::LocalExceptionWrapper&)
02171 {
02172 throw;
02173 }
02174 catch(const ::std::exception& __ex)
02175 {
02176 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02177 }
02178 catch(...)
02179 {
02180 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02181 }
02182 }
02183
02184 void
02185 IceDelegateD::Robots::IRobot::sendStart(const ::Ice::Context* __context)
02186 {
02187 class _DirectI : public ::IceInternal::Direct
02188 {
02189 public:
02190
02191 _DirectI(const ::Ice::Current& __current) :
02192 ::IceInternal::Direct(__current)
02193 {
02194 }
02195
02196 virtual ::Ice::DispatchStatus
02197 run(::Ice::Object* object)
02198 {
02199 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02200 if(!servant)
02201 {
02202 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02203 }
02204 servant->sendStart(_current);
02205 return ::Ice::DispatchOK;
02206 }
02207
02208 private:
02209
02210 };
02211
02212 ::Ice::Current __current;
02213 __initCurrent(__current, __Robots__IRobot__sendStart_name, ::Ice::Normal, __context);
02214 try
02215 {
02216 _DirectI __direct(__current);
02217 try
02218 {
02219 __direct.servant()->__collocDispatch(__direct);
02220 }
02221 catch(...)
02222 {
02223 __direct.destroy();
02224 throw;
02225 }
02226 __direct.destroy();
02227 }
02228 catch(const ::Ice::SystemException&)
02229 {
02230 throw;
02231 }
02232 catch(const ::IceInternal::LocalExceptionWrapper&)
02233 {
02234 throw;
02235 }
02236 catch(const ::std::exception& __ex)
02237 {
02238 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02239 }
02240 catch(...)
02241 {
02242 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02243 }
02244 }
02245
02246 void
02247 IceDelegateD::Robots::IRobot::setMode(::Robots::IRobotModes mode, const ::Ice::Context* __context)
02248 {
02249 class _DirectI : public ::IceInternal::Direct
02250 {
02251 public:
02252
02253 _DirectI(::Robots::IRobotModes mode, const ::Ice::Current& __current) :
02254 ::IceInternal::Direct(__current),
02255 _m_mode(mode)
02256 {
02257 }
02258
02259 virtual ::Ice::DispatchStatus
02260 run(::Ice::Object* object)
02261 {
02262 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02263 if(!servant)
02264 {
02265 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02266 }
02267 servant->setMode(_m_mode, _current);
02268 return ::Ice::DispatchOK;
02269 }
02270
02271 private:
02272
02273 ::Robots::IRobotModes _m_mode;
02274 };
02275
02276 ::Ice::Current __current;
02277 __initCurrent(__current, __Robots__IRobot__setMode_name, ::Ice::Normal, __context);
02278 try
02279 {
02280 _DirectI __direct(mode, __current);
02281 try
02282 {
02283 __direct.servant()->__collocDispatch(__direct);
02284 }
02285 catch(...)
02286 {
02287 __direct.destroy();
02288 throw;
02289 }
02290 __direct.destroy();
02291 }
02292 catch(const ::Ice::SystemException&)
02293 {
02294 throw;
02295 }
02296 catch(const ::IceInternal::LocalExceptionWrapper&)
02297 {
02298 throw;
02299 }
02300 catch(const ::std::exception& __ex)
02301 {
02302 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02303 }
02304 catch(...)
02305 {
02306 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02307 }
02308 }
02309
02310 void
02311 IceDelegateD::Robots::IRobot::setDemo(::Ice::Short demo, const ::Ice::Context* __context)
02312 {
02313 class _DirectI : public ::IceInternal::Direct
02314 {
02315 public:
02316
02317 _DirectI(::Ice::Short demo, const ::Ice::Current& __current) :
02318 ::IceInternal::Direct(__current),
02319 _m_demo(demo)
02320 {
02321 }
02322
02323 virtual ::Ice::DispatchStatus
02324 run(::Ice::Object* object)
02325 {
02326 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02327 if(!servant)
02328 {
02329 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02330 }
02331 servant->setDemo(_m_demo, _current);
02332 return ::Ice::DispatchOK;
02333 }
02334
02335 private:
02336
02337 ::Ice::Short _m_demo;
02338 };
02339
02340 ::Ice::Current __current;
02341 __initCurrent(__current, __Robots__IRobot__setDemo_name, ::Ice::Normal, __context);
02342 try
02343 {
02344 _DirectI __direct(demo, __current);
02345 try
02346 {
02347 __direct.servant()->__collocDispatch(__direct);
02348 }
02349 catch(...)
02350 {
02351 __direct.destroy();
02352 throw;
02353 }
02354 __direct.destroy();
02355 }
02356 catch(const ::Ice::SystemException&)
02357 {
02358 throw;
02359 }
02360 catch(const ::IceInternal::LocalExceptionWrapper&)
02361 {
02362 throw;
02363 }
02364 catch(const ::std::exception& __ex)
02365 {
02366 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02367 }
02368 catch(...)
02369 {
02370 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02371 }
02372 }
02373
02374 void
02375 IceDelegateD::Robots::IRobot::setLED(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Context* __context)
02376 {
02377 class _DirectI : public ::IceInternal::Direct
02378 {
02379 public:
02380
02381 _DirectI(::Ice::Short led, ::Ice::Short color, ::Ice::Short intensity, const ::Ice::Current& __current) :
02382 ::IceInternal::Direct(__current),
02383 _m_led(led),
02384 _m_color(color),
02385 _m_intensity(intensity)
02386 {
02387 }
02388
02389 virtual ::Ice::DispatchStatus
02390 run(::Ice::Object* object)
02391 {
02392 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02393 if(!servant)
02394 {
02395 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02396 }
02397 servant->setLED(_m_led, _m_color, _m_intensity, _current);
02398 return ::Ice::DispatchOK;
02399 }
02400
02401 private:
02402
02403 ::Ice::Short _m_led;
02404 ::Ice::Short _m_color;
02405 ::Ice::Short _m_intensity;
02406 };
02407
02408 ::Ice::Current __current;
02409 __initCurrent(__current, __Robots__IRobot__setLED_name, ::Ice::Normal, __context);
02410 try
02411 {
02412 _DirectI __direct(led, color, intensity, __current);
02413 try
02414 {
02415 __direct.servant()->__collocDispatch(__direct);
02416 }
02417 catch(...)
02418 {
02419 __direct.destroy();
02420 throw;
02421 }
02422 __direct.destroy();
02423 }
02424 catch(const ::Ice::SystemException&)
02425 {
02426 throw;
02427 }
02428 catch(const ::IceInternal::LocalExceptionWrapper&)
02429 {
02430 throw;
02431 }
02432 catch(const ::std::exception& __ex)
02433 {
02434 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02435 }
02436 catch(...)
02437 {
02438 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02439 }
02440 }
02441
02442 void
02443 IceDelegateD::Robots::IRobot::shutdown(const ::Ice::Context* __context)
02444 {
02445 class _DirectI : public ::IceInternal::Direct
02446 {
02447 public:
02448
02449 _DirectI(const ::Ice::Current& __current) :
02450 ::IceInternal::Direct(__current)
02451 {
02452 }
02453
02454 virtual ::Ice::DispatchStatus
02455 run(::Ice::Object* object)
02456 {
02457 ::Robots::IRobot* servant = dynamic_cast< ::Robots::IRobot*>(object);
02458 if(!servant)
02459 {
02460 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
02461 }
02462 servant->shutdown(_current);
02463 return ::Ice::DispatchOK;
02464 }
02465
02466 private:
02467
02468 };
02469
02470 ::Ice::Current __current;
02471 __initCurrent(__current, __Robots__IRobot__shutdown_name, ::Ice::Normal, __context);
02472 try
02473 {
02474 _DirectI __direct(__current);
02475 try
02476 {
02477 __direct.servant()->__collocDispatch(__direct);
02478 }
02479 catch(...)
02480 {
02481 __direct.destroy();
02482 throw;
02483 }
02484 __direct.destroy();
02485 }
02486 catch(const ::Ice::SystemException&)
02487 {
02488 throw;
02489 }
02490 catch(const ::IceInternal::LocalExceptionWrapper&)
02491 {
02492 throw;
02493 }
02494 catch(const ::std::exception& __ex)
02495 {
02496 ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
02497 }
02498 catch(...)
02499 {
02500 throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
02501 }
02502 }
02503
02504 ::Ice::ObjectPtr
02505 Robots::IRobot::ice_clone() const
02506 {
02507 throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
02508 return 0;
02509 }
02510
02511 static const ::std::string __Robots__IRobot_ids[2] =
02512 {
02513 "::Ice::Object",
02514 "::Robots::IRobot"
02515 };
02516
02517 bool
02518 Robots::IRobot::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
02519 {
02520 return ::std::binary_search(__Robots__IRobot_ids, __Robots__IRobot_ids + 2, _s);
02521 }
02522
02523 ::std::vector< ::std::string>
02524 Robots::IRobot::ice_ids(const ::Ice::Current&) const
02525 {
02526 return ::std::vector< ::std::string>(&__Robots__IRobot_ids[0], &__Robots__IRobot_ids[2]);
02527 }
02528
02529 const ::std::string&
02530 Robots::IRobot::ice_id(const ::Ice::Current&) const
02531 {
02532 return __Robots__IRobot_ids[1];
02533 }
02534
02535 const ::std::string&
02536 Robots::IRobot::ice_staticId()
02537 {
02538 return __Robots__IRobot_ids[1];
02539 }
02540
02541 ::Ice::DispatchStatus
02542 Robots::IRobot::___getSpeed(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02543 {
02544 __checkMode(::Ice::Normal, __current.mode);
02545 __inS.is()->skipEmptyEncaps();
02546 ::IceInternal::BasicStream* __os = __inS.os();
02547 ::Ice::Float __ret = getSpeed(__current);
02548 __os->write(__ret);
02549 return ::Ice::DispatchOK;
02550 }
02551
02552 ::Ice::DispatchStatus
02553 Robots::IRobot::___setSpeed(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02554 {
02555 __checkMode(::Ice::Normal, __current.mode);
02556 ::IceInternal::BasicStream* __is = __inS.is();
02557 __is->startReadEncaps();
02558 ::Ice::Float speed;
02559 __is->read(speed);
02560 __is->endReadEncaps();
02561 ::IceInternal::BasicStream* __os = __inS.os();
02562 ::Ice::Short __ret = setSpeed(speed, __current);
02563 __os->write(__ret);
02564 return ::Ice::DispatchOK;
02565 }
02566
02567 ::Ice::DispatchStatus
02568 Robots::IRobot::___getSteering(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02569 {
02570 __checkMode(::Ice::Normal, __current.mode);
02571 __inS.is()->skipEmptyEncaps();
02572 ::IceInternal::BasicStream* __os = __inS.os();
02573 ::Ice::Float __ret = getSteering(__current);
02574 __os->write(__ret);
02575 return ::Ice::DispatchOK;
02576 }
02577
02578 ::Ice::DispatchStatus
02579 Robots::IRobot::___setSteering(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02580 {
02581 __checkMode(::Ice::Normal, __current.mode);
02582 ::IceInternal::BasicStream* __is = __inS.is();
02583 __is->startReadEncaps();
02584 ::Ice::Float steeringPos;
02585 __is->read(steeringPos);
02586 __is->endReadEncaps();
02587 ::IceInternal::BasicStream* __os = __inS.os();
02588 ::Ice::Short __ret = setSteering(steeringPos, __current);
02589 __os->write(__ret);
02590 return ::Ice::DispatchOK;
02591 }
02592
02593 ::Ice::DispatchStatus
02594 Robots::IRobot::___getImageSensor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02595 {
02596 __checkMode(::Ice::Normal, __current.mode);
02597 ::IceInternal::BasicStream* __is = __inS.is();
02598 __is->startReadEncaps();
02599 ::Ice::Short i;
02600 bool useColor;
02601 __is->read(i);
02602 __is->read(useColor);
02603 __is->endReadEncaps();
02604 ::IceInternal::BasicStream* __os = __inS.os();
02605 ::ImageIceMod::ImageIce __ret = getImageSensor(i, useColor, __current);
02606 __ret.__write(__os);
02607 return ::Ice::DispatchOK;
02608 }
02609
02610 ::Ice::DispatchStatus
02611 Robots::IRobot::___getImageSensorDims(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02612 {
02613 __checkMode(::Ice::Normal, __current.mode);
02614 ::IceInternal::BasicStream* __is = __inS.is();
02615 __is->startReadEncaps();
02616 ::Ice::Short i;
02617 __is->read(i);
02618 __is->endReadEncaps();
02619 ::IceInternal::BasicStream* __os = __inS.os();
02620 ::ImageIceMod::DimsIce __ret = getImageSensorDims(i, __current);
02621 __ret.__write(__os);
02622 return ::Ice::DispatchOK;
02623 }
02624
02625 ::Ice::DispatchStatus
02626 Robots::IRobot::___getSensorValue(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02627 {
02628 __checkMode(::Ice::Normal, __current.mode);
02629 ::IceInternal::BasicStream* __is = __inS.is();
02630 __is->startReadEncaps();
02631 ::Ice::Short i;
02632 __is->read(i);
02633 __is->endReadEncaps();
02634 ::IceInternal::BasicStream* __os = __inS.os();
02635 ::Ice::Float __ret = getSensorValue(i, __current);
02636 __os->write(__ret);
02637 return ::Ice::DispatchOK;
02638 }
02639
02640 ::Ice::DispatchStatus
02641 Robots::IRobot::___getSensors(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02642 {
02643 __checkMode(::Ice::Normal, __current.mode);
02644 __inS.is()->skipEmptyEncaps();
02645 ::IceInternal::BasicStream* __os = __inS.os();
02646 ::Ice::Float xPos;
02647 ::Ice::Float yPos;
02648 ::Ice::Float ori;
02649 bool __ret = getSensors(xPos, yPos, ori, __current);
02650 __os->write(xPos);
02651 __os->write(yPos);
02652 __os->write(ori);
02653 __os->write(__ret);
02654 return ::Ice::DispatchOK;
02655 }
02656
02657 ::Ice::DispatchStatus
02658 Robots::IRobot::___getDistanceAngle(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02659 {
02660 __checkMode(::Ice::Normal, __current.mode);
02661 __inS.is()->skipEmptyEncaps();
02662 ::IceInternal::BasicStream* __os = __inS.os();
02663 ::Ice::Float dist;
02664 ::Ice::Float ang;
02665 bool __ret = getDistanceAngle(dist, ang, __current);
02666 __os->write(dist);
02667 __os->write(ang);
02668 __os->write(__ret);
02669 return ::Ice::DispatchOK;
02670 }
02671
02672 ::Ice::DispatchStatus
02673 Robots::IRobot::___motorsOff(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02674 {
02675 __checkMode(::Ice::Normal, __current.mode);
02676 ::IceInternal::BasicStream* __is = __inS.is();
02677 __is->startReadEncaps();
02678 ::Ice::Short i;
02679 __is->read(i);
02680 __is->endReadEncaps();
02681 motorsOff(i, __current);
02682 return ::Ice::DispatchOK;
02683 }
02684
02685 ::Ice::DispatchStatus
02686 Robots::IRobot::___setMotor(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02687 {
02688 __checkMode(::Ice::Normal, __current.mode);
02689 ::IceInternal::BasicStream* __is = __inS.is();
02690 __is->startReadEncaps();
02691 ::Ice::Short i;
02692 ::Ice::Float val;
02693 __is->read(i);
02694 __is->read(val);
02695 __is->endReadEncaps();
02696 setMotor(i, val, __current);
02697 return ::Ice::DispatchOK;
02698 }
02699
02700 ::Ice::DispatchStatus
02701 Robots::IRobot::___sendRawCmd(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02702 {
02703 __checkMode(::Ice::Normal, __current.mode);
02704 ::IceInternal::BasicStream* __is = __inS.is();
02705 __is->startReadEncaps();
02706 ::std::string data;
02707 __is->read(data);
02708 __is->endReadEncaps();
02709 ::IceInternal::BasicStream* __os = __inS.os();
02710 ::Ice::Short __ret = sendRawCmd(data, __current);
02711 __os->write(__ret);
02712 return ::Ice::DispatchOK;
02713 }
02714
02715 ::Ice::DispatchStatus
02716 Robots::IRobot::___playSong(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02717 {
02718 __checkMode(::Ice::Normal, __current.mode);
02719 ::IceInternal::BasicStream* __is = __inS.is();
02720 __is->startReadEncaps();
02721 ::Ice::Short song;
02722 __is->read(song);
02723 __is->endReadEncaps();
02724 playSong(song, __current);
02725 return ::Ice::DispatchOK;
02726 }
02727
02728 ::Ice::DispatchStatus
02729 Robots::IRobot::___sendStart(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02730 {
02731 __checkMode(::Ice::Normal, __current.mode);
02732 __inS.is()->skipEmptyEncaps();
02733 sendStart(__current);
02734 return ::Ice::DispatchOK;
02735 }
02736
02737 ::Ice::DispatchStatus
02738 Robots::IRobot::___setMode(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02739 {
02740 __checkMode(::Ice::Normal, __current.mode);
02741 ::IceInternal::BasicStream* __is = __inS.is();
02742 __is->startReadEncaps();
02743 ::Robots::IRobotModes mode;
02744 ::Robots::__read(__is, mode);
02745 __is->endReadEncaps();
02746 setMode(mode, __current);
02747 return ::Ice::DispatchOK;
02748 }
02749
02750 ::Ice::DispatchStatus
02751 Robots::IRobot::___setDemo(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02752 {
02753 __checkMode(::Ice::Normal, __current.mode);
02754 ::IceInternal::BasicStream* __is = __inS.is();
02755 __is->startReadEncaps();
02756 ::Ice::Short demo;
02757 __is->read(demo);
02758 __is->endReadEncaps();
02759 setDemo(demo, __current);
02760 return ::Ice::DispatchOK;
02761 }
02762
02763 ::Ice::DispatchStatus
02764 Robots::IRobot::___setLED(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02765 {
02766 __checkMode(::Ice::Normal, __current.mode);
02767 ::IceInternal::BasicStream* __is = __inS.is();
02768 __is->startReadEncaps();
02769 ::Ice::Short led;
02770 ::Ice::Short color;
02771 ::Ice::Short intensity;
02772 __is->read(led);
02773 __is->read(color);
02774 __is->read(intensity);
02775 __is->endReadEncaps();
02776 setLED(led, color, intensity, __current);
02777 return ::Ice::DispatchOK;
02778 }
02779
02780 ::Ice::DispatchStatus
02781 Robots::IRobot::___shutdown(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
02782 {
02783 __checkMode(::Ice::Normal, __current.mode);
02784 __inS.is()->skipEmptyEncaps();
02785 shutdown(__current);
02786 return ::Ice::DispatchOK;
02787 }
02788
02789 static ::std::string __Robots__IRobot_all[] =
02790 {
02791 "getDistanceAngle",
02792 "getImageSensor",
02793 "getImageSensorDims",
02794 "getSensorValue",
02795 "getSensors",
02796 "getSpeed",
02797 "getSteering",
02798 "ice_id",
02799 "ice_ids",
02800 "ice_isA",
02801 "ice_ping",
02802 "motorsOff",
02803 "playSong",
02804 "sendRawCmd",
02805 "sendStart",
02806 "setDemo",
02807 "setLED",
02808 "setMode",
02809 "setMotor",
02810 "setSpeed",
02811 "setSteering",
02812 "shutdown"
02813 };
02814
02815 ::Ice::DispatchStatus
02816 Robots::IRobot::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
02817 {
02818 ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__Robots__IRobot_all, __Robots__IRobot_all + 22, current.operation);
02819 if(r.first == r.second)
02820 {
02821 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
02822 }
02823
02824 switch(r.first - __Robots__IRobot_all)
02825 {
02826 case 0:
02827 {
02828 return ___getDistanceAngle(in, current);
02829 }
02830 case 1:
02831 {
02832 return ___getImageSensor(in, current);
02833 }
02834 case 2:
02835 {
02836 return ___getImageSensorDims(in, current);
02837 }
02838 case 3:
02839 {
02840 return ___getSensorValue(in, current);
02841 }
02842 case 4:
02843 {
02844 return ___getSensors(in, current);
02845 }
02846 case 5:
02847 {
02848 return ___getSpeed(in, current);
02849 }
02850 case 6:
02851 {
02852 return ___getSteering(in, current);
02853 }
02854 case 7:
02855 {
02856 return ___ice_id(in, current);
02857 }
02858 case 8:
02859 {
02860 return ___ice_ids(in, current);
02861 }
02862 case 9:
02863 {
02864 return ___ice_isA(in, current);
02865 }
02866 case 10:
02867 {
02868 return ___ice_ping(in, current);
02869 }
02870 case 11:
02871 {
02872 return ___motorsOff(in, current);
02873 }
02874 case 12:
02875 {
02876 return ___playSong(in, current);
02877 }
02878 case 13:
02879 {
02880 return ___sendRawCmd(in, current);
02881 }
02882 case 14:
02883 {
02884 return ___sendStart(in, current);
02885 }
02886 case 15:
02887 {
02888 return ___setDemo(in, current);
02889 }
02890 case 16:
02891 {
02892 return ___setLED(in, current);
02893 }
02894 case 17:
02895 {
02896 return ___setMode(in, current);
02897 }
02898 case 18:
02899 {
02900 return ___setMotor(in, current);
02901 }
02902 case 19:
02903 {
02904 return ___setSpeed(in, current);
02905 }
02906 case 20:
02907 {
02908 return ___setSteering(in, current);
02909 }
02910 case 21:
02911 {
02912 return ___shutdown(in, current);
02913 }
02914 }
02915
02916 assert(false);
02917 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
02918 }
02919
02920 void
02921 Robots::IRobot::__write(::IceInternal::BasicStream* __os) const
02922 {
02923 __os->writeTypeId(ice_staticId());
02924 __os->startWriteSlice();
02925 __os->endWriteSlice();
02926 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02927 Object::__write(__os);
02928 #else
02929 ::Ice::Object::__write(__os);
02930 #endif
02931 }
02932
02933 void
02934 Robots::IRobot::__read(::IceInternal::BasicStream* __is, bool __rid)
02935 {
02936 if(__rid)
02937 {
02938 ::std::string myId;
02939 __is->readTypeId(myId);
02940 }
02941 __is->startReadSlice();
02942 __is->endReadSlice();
02943 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
02944 Object::__read(__is, true);
02945 #else
02946 ::Ice::Object::__read(__is, true);
02947 #endif
02948 }
02949
02950 void
02951 Robots::IRobot::__write(const ::Ice::OutputStreamPtr&) const
02952 {
02953 Ice::MarshalException ex(__FILE__, __LINE__);
02954 ex.reason = "type Robots::IRobot was not generated with stream support";
02955 throw ex;
02956 }
02957
02958 void
02959 Robots::IRobot::__read(const ::Ice::InputStreamPtr&, bool)
02960 {
02961 Ice::MarshalException ex(__FILE__, __LINE__);
02962 ex.reason = "type Robots::IRobot was not generated with stream support";
02963 throw ex;
02964 }
02965
02966 void
02967 Robots::__patch__IRobotPtr(void* __addr, ::Ice::ObjectPtr& v)
02968 {
02969 ::Robots::IRobotPtr* p = static_cast< ::Robots::IRobotPtr*>(__addr);
02970 assert(p);
02971 *p = ::Robots::IRobotPtr::dynamicCast(v);
02972 if(v && !*p)
02973 {
02974 IceInternal::Ex::throwUOE(::Robots::IRobot::ice_staticId(), v->ice_id());
02975 }
02976 }
02977
02978 bool
02979 Robots::operator==(const ::Robots::IRobot& l, const ::Robots::IRobot& r)
02980 {
02981 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
02982 }
02983
02984 bool
02985 Robots::operator<(const ::Robots::IRobot& l, const ::Robots::IRobot& r)
02986 {
02987 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
02988 }
1.6.3