Events.ice.C

00001 // **********************************************************************
00002 //
00003 // Copyright (c) 2003-2009 ZeroC, Inc. All rights reserved.
00004 //
00005 // This copy of Ice is licensed to you under the terms described in the
00006 // ICE_LICENSE file included in this distribution.
00007 //
00008 // **********************************************************************
00009 
00010 // Ice version 3.3.1
00011 // Generated from file `Events.ice'
00012 
00013 #include <Events.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 __EventsNS__Events__evolve_name = "evolve";
00033 
00034 ::Ice::Object* IceInternal::upCast(::EventsNS::Event* p) { return p; }
00035 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Event* p) { return p; }
00036 
00037 ::Ice::Object* IceInternal::upCast(::EventsNS::Message1* p) { return p; }
00038 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Message1* p) { return p; }
00039 
00040 ::Ice::Object* IceInternal::upCast(::EventsNS::Message2* p) { return p; }
00041 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Message2* p) { return p; }
00042 
00043 ::Ice::Object* IceInternal::upCast(::EventsNS::Events* p) { return p; }
00044 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::EventsNS::Events* p) { return p; }
00045 
00046 ::Ice::Object* IceInternal::upCast(::TestPub::Publisher1* p) { return p; }
00047 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Publisher1* p) { return p; }
00048 
00049 ::Ice::Object* IceInternal::upCast(::TestPub::Publisher2* p) { return p; }
00050 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Publisher2* p) { return p; }
00051 
00052 ::Ice::Object* IceInternal::upCast(::TestPub::Subscriber1* p) { return p; }
00053 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Subscriber1* p) { return p; }
00054 
00055 ::Ice::Object* IceInternal::upCast(::TestPub::Subscriber2* p) { return p; }
00056 ::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy::TestPub::Subscriber2* p) { return p; }
00057 
00058 void
00059 EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::EventPrx& v)
00060 {
00061     ::Ice::ObjectPrx proxy;
00062     __is->read(proxy);
00063     if(!proxy)
00064     {
00065         v = 0;
00066     }
00067     else
00068     {
00069         v = new ::IceProxy::EventsNS::Event;
00070         v->__copyFrom(proxy);
00071     }
00072 }
00073 
00074 void
00075 EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::Message1Prx& v)
00076 {
00077     ::Ice::ObjectPrx proxy;
00078     __is->read(proxy);
00079     if(!proxy)
00080     {
00081         v = 0;
00082     }
00083     else
00084     {
00085         v = new ::IceProxy::EventsNS::Message1;
00086         v->__copyFrom(proxy);
00087     }
00088 }
00089 
00090 void
00091 EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::Message2Prx& v)
00092 {
00093     ::Ice::ObjectPrx proxy;
00094     __is->read(proxy);
00095     if(!proxy)
00096     {
00097         v = 0;
00098     }
00099     else
00100     {
00101         v = new ::IceProxy::EventsNS::Message2;
00102         v->__copyFrom(proxy);
00103     }
00104 }
00105 
00106 void
00107 EventsNS::__read(::IceInternal::BasicStream* __is, ::EventsNS::EventsPrx& v)
00108 {
00109     ::Ice::ObjectPrx proxy;
00110     __is->read(proxy);
00111     if(!proxy)
00112     {
00113         v = 0;
00114     }
00115     else
00116     {
00117         v = new ::IceProxy::EventsNS::Events;
00118         v->__copyFrom(proxy);
00119     }
00120 }
00121 
00122 void
00123 TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Publisher1Prx& v)
00124 {
00125     ::Ice::ObjectPrx proxy;
00126     __is->read(proxy);
00127     if(!proxy)
00128     {
00129         v = 0;
00130     }
00131     else
00132     {
00133         v = new ::IceProxy::TestPub::Publisher1;
00134         v->__copyFrom(proxy);
00135     }
00136 }
00137 
00138 void
00139 TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Publisher2Prx& v)
00140 {
00141     ::Ice::ObjectPrx proxy;
00142     __is->read(proxy);
00143     if(!proxy)
00144     {
00145         v = 0;
00146     }
00147     else
00148     {
00149         v = new ::IceProxy::TestPub::Publisher2;
00150         v->__copyFrom(proxy);
00151     }
00152 }
00153 
00154 void
00155 TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Subscriber1Prx& v)
00156 {
00157     ::Ice::ObjectPrx proxy;
00158     __is->read(proxy);
00159     if(!proxy)
00160     {
00161         v = 0;
00162     }
00163     else
00164     {
00165         v = new ::IceProxy::TestPub::Subscriber1;
00166         v->__copyFrom(proxy);
00167     }
00168 }
00169 
00170 void
00171 TestPub::__read(::IceInternal::BasicStream* __is, ::TestPub::Subscriber2Prx& v)
00172 {
00173     ::Ice::ObjectPrx proxy;
00174     __is->read(proxy);
00175     if(!proxy)
00176     {
00177         v = 0;
00178     }
00179     else
00180     {
00181         v = new ::IceProxy::TestPub::Subscriber2;
00182         v->__copyFrom(proxy);
00183     }
00184 }
00185 
00186 bool
00187 EventsNS::AMI_Events_evolve::__invoke(const ::EventsNS::EventsPrx& __prx, const ::EventsNS::EventPtr& e, const ::Ice::Context* __ctx)
00188 {
00189     __acquireCallback(__prx);
00190     try
00191     {
00192         __prepare(__prx, __EventsNS__Events__evolve_name, ::Ice::Normal, __ctx);
00193         __os->write(::Ice::ObjectPtr(::IceInternal::upCast(e.get())));
00194         __os->writePendingObjects();
00195         __os->endWriteEncaps();
00196         return __send();
00197     }
00198     catch(const ::Ice::LocalException& __ex)
00199     {
00200         __releaseCallback(__ex);
00201         return false;
00202     }
00203 }
00204 
00205 void
00206 EventsNS::AMI_Events_evolve::__response(bool __ok)
00207 {
00208     try
00209     {
00210         if(!__ok)
00211         {
00212             try
00213             {
00214                 __throwUserException();
00215             }
00216             catch(const ::Ice::UserException& __ex)
00217             {
00218                 throw ::Ice::UnknownUserException(__FILE__, __LINE__, __ex.ice_name());
00219             }
00220             return;
00221         }
00222         __is->skipEmptyEncaps();
00223     }
00224     catch(const ::Ice::LocalException& __ex)
00225     {
00226         __finished(__ex);
00227         return;
00228     }
00229     ice_response();
00230     __releaseCallback();
00231 }
00232 
00233 const ::std::string&
00234 IceProxy::EventsNS::Event::ice_staticId()
00235 {
00236     return ::EventsNS::Event::ice_staticId();
00237 }
00238 
00239 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00240 IceProxy::EventsNS::Event::__createDelegateM()
00241 {
00242     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Event);
00243 }
00244 
00245 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00246 IceProxy::EventsNS::Event::__createDelegateD()
00247 {
00248     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Event);
00249 }
00250 
00251 ::IceProxy::Ice::Object*
00252 IceProxy::EventsNS::Event::__newInstance() const
00253 {
00254     return new Event;
00255 }
00256 
00257 const ::std::string&
00258 IceProxy::EventsNS::Message1::ice_staticId()
00259 {
00260     return ::EventsNS::Message1::ice_staticId();
00261 }
00262 
00263 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00264 IceProxy::EventsNS::Message1::__createDelegateM()
00265 {
00266     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Message1);
00267 }
00268 
00269 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00270 IceProxy::EventsNS::Message1::__createDelegateD()
00271 {
00272     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Message1);
00273 }
00274 
00275 ::IceProxy::Ice::Object*
00276 IceProxy::EventsNS::Message1::__newInstance() const
00277 {
00278     return new Message1;
00279 }
00280 
00281 const ::std::string&
00282 IceProxy::EventsNS::Message2::ice_staticId()
00283 {
00284     return ::EventsNS::Message2::ice_staticId();
00285 }
00286 
00287 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00288 IceProxy::EventsNS::Message2::__createDelegateM()
00289 {
00290     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Message2);
00291 }
00292 
00293 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00294 IceProxy::EventsNS::Message2::__createDelegateD()
00295 {
00296     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Message2);
00297 }
00298 
00299 ::IceProxy::Ice::Object*
00300 IceProxy::EventsNS::Message2::__newInstance() const
00301 {
00302     return new Message2;
00303 }
00304 
00305 void
00306 IceProxy::EventsNS::Events::evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context* __ctx)
00307 {
00308     int __cnt = 0;
00309     while(true)
00310     {
00311         ::IceInternal::Handle< ::IceDelegate::Ice::Object> __delBase;
00312         try
00313         {
00314 #if defined(__BCPLUSPLUS__) && (__BCPLUSPLUS__ >= 0x0600) // C++Builder 2009 compiler bug
00315             IceUtil::DummyBCC dummy;
00316 #endif
00317             __delBase = __getDelegate(false);
00318             ::IceDelegate::EventsNS::Events* __del = dynamic_cast< ::IceDelegate::EventsNS::Events*>(__delBase.get());
00319             __del->evolve(e, __ctx);
00320             return;
00321         }
00322         catch(const ::IceInternal::LocalExceptionWrapper& __ex)
00323         {
00324             __handleExceptionWrapper(__delBase, __ex, 0);
00325         }
00326         catch(const ::Ice::LocalException& __ex)
00327         {
00328             __handleException(__delBase, __ex, 0, __cnt);
00329         }
00330     }
00331 }
00332 
00333 bool
00334 IceProxy::EventsNS::Events::evolve_async(const ::EventsNS::AMI_Events_evolvePtr& __cb, const ::EventsNS::EventPtr& e)
00335 {
00336     return __cb->__invoke(this, e, 0);
00337 }
00338 
00339 bool
00340 IceProxy::EventsNS::Events::evolve_async(const ::EventsNS::AMI_Events_evolvePtr& __cb, const ::EventsNS::EventPtr& e, const ::Ice::Context& __ctx)
00341 {
00342     return __cb->__invoke(this, e, &__ctx);
00343 }
00344 
00345 const ::std::string&
00346 IceProxy::EventsNS::Events::ice_staticId()
00347 {
00348     return ::EventsNS::Events::ice_staticId();
00349 }
00350 
00351 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00352 IceProxy::EventsNS::Events::__createDelegateM()
00353 {
00354     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::EventsNS::Events);
00355 }
00356 
00357 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00358 IceProxy::EventsNS::Events::__createDelegateD()
00359 {
00360     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::EventsNS::Events);
00361 }
00362 
00363 ::IceProxy::Ice::Object*
00364 IceProxy::EventsNS::Events::__newInstance() const
00365 {
00366     return new Events;
00367 }
00368 
00369 const ::std::string&
00370 IceProxy::TestPub::Publisher1::ice_staticId()
00371 {
00372     return ::TestPub::Publisher1::ice_staticId();
00373 }
00374 
00375 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00376 IceProxy::TestPub::Publisher1::__createDelegateM()
00377 {
00378     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Publisher1);
00379 }
00380 
00381 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00382 IceProxy::TestPub::Publisher1::__createDelegateD()
00383 {
00384     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Publisher1);
00385 }
00386 
00387 ::IceProxy::Ice::Object*
00388 IceProxy::TestPub::Publisher1::__newInstance() const
00389 {
00390     return new Publisher1;
00391 }
00392 
00393 const ::std::string&
00394 IceProxy::TestPub::Publisher2::ice_staticId()
00395 {
00396     return ::TestPub::Publisher2::ice_staticId();
00397 }
00398 
00399 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00400 IceProxy::TestPub::Publisher2::__createDelegateM()
00401 {
00402     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Publisher2);
00403 }
00404 
00405 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00406 IceProxy::TestPub::Publisher2::__createDelegateD()
00407 {
00408     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Publisher2);
00409 }
00410 
00411 ::IceProxy::Ice::Object*
00412 IceProxy::TestPub::Publisher2::__newInstance() const
00413 {
00414     return new Publisher2;
00415 }
00416 
00417 const ::std::string&
00418 IceProxy::TestPub::Subscriber1::ice_staticId()
00419 {
00420     return ::TestPub::Subscriber1::ice_staticId();
00421 }
00422 
00423 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00424 IceProxy::TestPub::Subscriber1::__createDelegateM()
00425 {
00426     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Subscriber1);
00427 }
00428 
00429 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00430 IceProxy::TestPub::Subscriber1::__createDelegateD()
00431 {
00432     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Subscriber1);
00433 }
00434 
00435 ::IceProxy::Ice::Object*
00436 IceProxy::TestPub::Subscriber1::__newInstance() const
00437 {
00438     return new Subscriber1;
00439 }
00440 
00441 const ::std::string&
00442 IceProxy::TestPub::Subscriber2::ice_staticId()
00443 {
00444     return ::TestPub::Subscriber2::ice_staticId();
00445 }
00446 
00447 ::IceInternal::Handle< ::IceDelegateM::Ice::Object>
00448 IceProxy::TestPub::Subscriber2::__createDelegateM()
00449 {
00450     return ::IceInternal::Handle< ::IceDelegateM::Ice::Object>(new ::IceDelegateM::TestPub::Subscriber2);
00451 }
00452 
00453 ::IceInternal::Handle< ::IceDelegateD::Ice::Object>
00454 IceProxy::TestPub::Subscriber2::__createDelegateD()
00455 {
00456     return ::IceInternal::Handle< ::IceDelegateD::Ice::Object>(new ::IceDelegateD::TestPub::Subscriber2);
00457 }
00458 
00459 ::IceProxy::Ice::Object*
00460 IceProxy::TestPub::Subscriber2::__newInstance() const
00461 {
00462     return new Subscriber2;
00463 }
00464 
00465 void
00466 IceDelegateM::EventsNS::Events::evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context* __context)
00467 {
00468     ::IceInternal::Outgoing __og(__handler.get(), __EventsNS__Events__evolve_name, ::Ice::Normal, __context);
00469     try
00470     {
00471         ::IceInternal::BasicStream* __os = __og.os();
00472         __os->write(::Ice::ObjectPtr(::IceInternal::upCast(e.get())));
00473         __os->writePendingObjects();
00474     }
00475     catch(const ::Ice::LocalException& __ex)
00476     {
00477         __og.abort(__ex);
00478     }
00479     bool __ok = __og.invoke();
00480     if(!__og.is()->b.empty())
00481     {
00482         try
00483         {
00484             if(!__ok)
00485             {
00486                 try
00487                 {
00488                     __og.throwUserException();
00489                 }
00490                 catch(const ::Ice::UserException& __ex)
00491                 {
00492                     ::Ice::UnknownUserException __uue(__FILE__, __LINE__, __ex.ice_name());
00493                     throw __uue;
00494                 }
00495             }
00496             __og.is()->skipEmptyEncaps();
00497         }
00498         catch(const ::Ice::LocalException& __ex)
00499         {
00500             throw ::IceInternal::LocalExceptionWrapper(__ex, false);
00501         }
00502     }
00503 }
00504 
00505 void
00506 IceDelegateD::EventsNS::Events::evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context* __context)
00507 {
00508     class _DirectI : public ::IceInternal::Direct
00509     {
00510     public:
00511 
00512         _DirectI(const ::EventsNS::EventPtr& e, const ::Ice::Current& __current) :
00513             ::IceInternal::Direct(__current),
00514             _m_e(e)
00515         {
00516         }
00517 
00518         virtual ::Ice::DispatchStatus
00519         run(::Ice::Object* object)
00520         {
00521             ::EventsNS::Events* servant = dynamic_cast< ::EventsNS::Events*>(object);
00522             if(!servant)
00523             {
00524                 throw ::Ice::OperationNotExistException(__FILE__, __LINE__, _current.id, _current.facet, _current.operation);
00525             }
00526             servant->evolve(_m_e, _current);
00527             return ::Ice::DispatchOK;
00528         }
00529 
00530     private:
00531 
00532         const ::EventsNS::EventPtr& _m_e;
00533     };
00534 
00535     ::Ice::Current __current;
00536     __initCurrent(__current, __EventsNS__Events__evolve_name, ::Ice::Normal, __context);
00537     try
00538     {
00539         _DirectI __direct(e, __current);
00540         try
00541         {
00542             __direct.servant()->__collocDispatch(__direct);
00543         }
00544         catch(...)
00545         {
00546             __direct.destroy();
00547             throw;
00548         }
00549         __direct.destroy();
00550     }
00551     catch(const ::Ice::SystemException&)
00552     {
00553         throw;
00554     }
00555     catch(const ::IceInternal::LocalExceptionWrapper&)
00556     {
00557         throw;
00558     }
00559     catch(const ::std::exception& __ex)
00560     {
00561         ::IceInternal::LocalExceptionWrapper::throwWrapper(__ex);
00562     }
00563     catch(...)
00564     {
00565         throw ::IceInternal::LocalExceptionWrapper(::Ice::UnknownException(__FILE__, __LINE__, "unknown c++ exception"), false);
00566     }
00567 }
00568 
00569 EventsNS::Event::Event(::Ice::Int __ice_id) :
00570     id(__ice_id)
00571 {
00572 }
00573 
00574 ::Ice::ObjectPtr
00575 EventsNS::Event::ice_clone() const
00576 {
00577     ::EventsNS::EventPtr __p = new ::EventsNS::Event(*this);
00578     return __p;
00579 }
00580 
00581 static const ::std::string __EventsNS__Event_ids[2] =
00582 {
00583     "::EventsNS::Event",
00584     "::Ice::Object"
00585 };
00586 
00587 bool
00588 EventsNS::Event::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00589 {
00590     return ::std::binary_search(__EventsNS__Event_ids, __EventsNS__Event_ids + 2, _s);
00591 }
00592 
00593 ::std::vector< ::std::string>
00594 EventsNS::Event::ice_ids(const ::Ice::Current&) const
00595 {
00596     return ::std::vector< ::std::string>(&__EventsNS__Event_ids[0], &__EventsNS__Event_ids[2]);
00597 }
00598 
00599 const ::std::string&
00600 EventsNS::Event::ice_id(const ::Ice::Current&) const
00601 {
00602     return __EventsNS__Event_ids[0];
00603 }
00604 
00605 const ::std::string&
00606 EventsNS::Event::ice_staticId()
00607 {
00608     return __EventsNS__Event_ids[0];
00609 }
00610 
00611 void
00612 EventsNS::Event::__write(::IceInternal::BasicStream* __os) const
00613 {
00614     __os->writeTypeId(ice_staticId());
00615     __os->startWriteSlice();
00616     __os->write(id);
00617     __os->endWriteSlice();
00618 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00619     Object::__write(__os);
00620 #else
00621     ::Ice::Object::__write(__os);
00622 #endif
00623 }
00624 
00625 void
00626 EventsNS::Event::__read(::IceInternal::BasicStream* __is, bool __rid)
00627 {
00628     if(__rid)
00629     {
00630         ::std::string myId;
00631         __is->readTypeId(myId);
00632     }
00633     __is->startReadSlice();
00634     __is->read(id);
00635     __is->endReadSlice();
00636 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00637     Object::__read(__is, true);
00638 #else
00639     ::Ice::Object::__read(__is, true);
00640 #endif
00641 }
00642 
00643 void
00644 EventsNS::Event::__write(const ::Ice::OutputStreamPtr&) const
00645 {
00646     Ice::MarshalException ex(__FILE__, __LINE__);
00647     ex.reason = "type EventsNS::Event was not generated with stream support";
00648     throw ex;
00649 }
00650 
00651 void
00652 EventsNS::Event::__read(const ::Ice::InputStreamPtr&, bool)
00653 {
00654     Ice::MarshalException ex(__FILE__, __LINE__);
00655     ex.reason = "type EventsNS::Event was not generated with stream support";
00656     throw ex;
00657 }
00658 
00659 class __F__EventsNS__Event : public ::Ice::ObjectFactory
00660 {
00661 public:
00662 
00663     virtual ::Ice::ObjectPtr
00664     create(const ::std::string& type)
00665     {
00666         assert(type == ::EventsNS::Event::ice_staticId());
00667         return new ::EventsNS::Event;
00668     }
00669 
00670     virtual void
00671     destroy()
00672     {
00673     }
00674 };
00675 
00676 static ::Ice::ObjectFactoryPtr __F__EventsNS__Event_Ptr = new __F__EventsNS__Event;
00677 
00678 const ::Ice::ObjectFactoryPtr&
00679 EventsNS::Event::ice_factory()
00680 {
00681     return __F__EventsNS__Event_Ptr;
00682 }
00683 
00684 class __F__EventsNS__Event__Init
00685 {
00686 public:
00687 
00688     __F__EventsNS__Event__Init()
00689     {
00690         ::IceInternal::factoryTable->addObjectFactory(::EventsNS::Event::ice_staticId(), ::EventsNS::Event::ice_factory());
00691     }
00692 
00693     ~__F__EventsNS__Event__Init()
00694     {
00695         ::IceInternal::factoryTable->removeObjectFactory(::EventsNS::Event::ice_staticId());
00696     }
00697 };
00698 
00699 static __F__EventsNS__Event__Init __F__EventsNS__Event__i;
00700 
00701 #ifdef __APPLE__
00702 extern "C" { void __F__EventsNS__Event__initializer() {} }
00703 #endif
00704 
00705 void
00706 EventsNS::__patch__EventPtr(void* __addr, ::Ice::ObjectPtr& v)
00707 {
00708     ::EventsNS::EventPtr* p = static_cast< ::EventsNS::EventPtr*>(__addr);
00709     assert(p);
00710     *p = ::EventsNS::EventPtr::dynamicCast(v);
00711     if(v && !*p)
00712     {
00713         IceInternal::Ex::throwUOE(::EventsNS::Event::ice_staticId(), v->ice_id());
00714     }
00715 }
00716 
00717 bool
00718 EventsNS::operator==(const ::EventsNS::Event& l, const ::EventsNS::Event& r)
00719 {
00720     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
00721 }
00722 
00723 bool
00724 EventsNS::operator<(const ::EventsNS::Event& l, const ::EventsNS::Event& r)
00725 {
00726     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
00727 }
00728 
00729 EventsNS::Message1::Message1(::Ice::Int __ice_id, ::Ice::Int __ice_m, const ::std::string& __ice_msg) :
00730 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00731     Event(__ice_id)
00732 #else
00733     ::EventsNS::Event(__ice_id)
00734 #endif
00735 ,
00736     m(__ice_m),
00737     msg(__ice_msg)
00738 {
00739 }
00740 
00741 ::Ice::ObjectPtr
00742 EventsNS::Message1::ice_clone() const
00743 {
00744     ::EventsNS::Message1Ptr __p = new ::EventsNS::Message1(*this);
00745     return __p;
00746 }
00747 
00748 static const ::std::string __EventsNS__Message1_ids[3] =
00749 {
00750     "::EventsNS::Event",
00751     "::EventsNS::Message1",
00752     "::Ice::Object"
00753 };
00754 
00755 bool
00756 EventsNS::Message1::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00757 {
00758     return ::std::binary_search(__EventsNS__Message1_ids, __EventsNS__Message1_ids + 3, _s);
00759 }
00760 
00761 ::std::vector< ::std::string>
00762 EventsNS::Message1::ice_ids(const ::Ice::Current&) const
00763 {
00764     return ::std::vector< ::std::string>(&__EventsNS__Message1_ids[0], &__EventsNS__Message1_ids[3]);
00765 }
00766 
00767 const ::std::string&
00768 EventsNS::Message1::ice_id(const ::Ice::Current&) const
00769 {
00770     return __EventsNS__Message1_ids[1];
00771 }
00772 
00773 const ::std::string&
00774 EventsNS::Message1::ice_staticId()
00775 {
00776     return __EventsNS__Message1_ids[1];
00777 }
00778 
00779 void
00780 EventsNS::Message1::__write(::IceInternal::BasicStream* __os) const
00781 {
00782     __os->writeTypeId(ice_staticId());
00783     __os->startWriteSlice();
00784     __os->write(m);
00785     __os->write(msg);
00786     __os->endWriteSlice();
00787 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00788     Event::__write(__os);
00789 #else
00790     ::EventsNS::Event::__write(__os);
00791 #endif
00792 }
00793 
00794 void
00795 EventsNS::Message1::__read(::IceInternal::BasicStream* __is, bool __rid)
00796 {
00797     if(__rid)
00798     {
00799         ::std::string myId;
00800         __is->readTypeId(myId);
00801     }
00802     __is->startReadSlice();
00803     __is->read(m);
00804     __is->read(msg);
00805     __is->endReadSlice();
00806 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00807     Event::__read(__is, true);
00808 #else
00809     ::EventsNS::Event::__read(__is, true);
00810 #endif
00811 }
00812 
00813 void
00814 EventsNS::Message1::__write(const ::Ice::OutputStreamPtr&) const
00815 {
00816     Ice::MarshalException ex(__FILE__, __LINE__);
00817     ex.reason = "type EventsNS::Message1 was not generated with stream support";
00818     throw ex;
00819 }
00820 
00821 void
00822 EventsNS::Message1::__read(const ::Ice::InputStreamPtr&, bool)
00823 {
00824     Ice::MarshalException ex(__FILE__, __LINE__);
00825     ex.reason = "type EventsNS::Message1 was not generated with stream support";
00826     throw ex;
00827 }
00828 
00829 class __F__EventsNS__Message1 : public ::Ice::ObjectFactory
00830 {
00831 public:
00832 
00833     virtual ::Ice::ObjectPtr
00834     create(const ::std::string& type)
00835     {
00836         assert(type == ::EventsNS::Message1::ice_staticId());
00837         return new ::EventsNS::Message1;
00838     }
00839 
00840     virtual void
00841     destroy()
00842     {
00843     }
00844 };
00845 
00846 static ::Ice::ObjectFactoryPtr __F__EventsNS__Message1_Ptr = new __F__EventsNS__Message1;
00847 
00848 const ::Ice::ObjectFactoryPtr&
00849 EventsNS::Message1::ice_factory()
00850 {
00851     return __F__EventsNS__Message1_Ptr;
00852 }
00853 
00854 class __F__EventsNS__Message1__Init
00855 {
00856 public:
00857 
00858     __F__EventsNS__Message1__Init()
00859     {
00860         ::IceInternal::factoryTable->addObjectFactory(::EventsNS::Message1::ice_staticId(), ::EventsNS::Message1::ice_factory());
00861     }
00862 
00863     ~__F__EventsNS__Message1__Init()
00864     {
00865         ::IceInternal::factoryTable->removeObjectFactory(::EventsNS::Message1::ice_staticId());
00866     }
00867 };
00868 
00869 static __F__EventsNS__Message1__Init __F__EventsNS__Message1__i;
00870 
00871 #ifdef __APPLE__
00872 extern "C" { void __F__EventsNS__Message1__initializer() {} }
00873 #endif
00874 
00875 void
00876 EventsNS::__patch__Message1Ptr(void* __addr, ::Ice::ObjectPtr& v)
00877 {
00878     ::EventsNS::Message1Ptr* p = static_cast< ::EventsNS::Message1Ptr*>(__addr);
00879     assert(p);
00880     *p = ::EventsNS::Message1Ptr::dynamicCast(v);
00881     if(v && !*p)
00882     {
00883         IceInternal::Ex::throwUOE(::EventsNS::Message1::ice_staticId(), v->ice_id());
00884     }
00885 }
00886 
00887 bool
00888 EventsNS::operator==(const ::EventsNS::Message1& l, const ::EventsNS::Message1& r)
00889 {
00890     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
00891 }
00892 
00893 bool
00894 EventsNS::operator<(const ::EventsNS::Message1& l, const ::EventsNS::Message1& r)
00895 {
00896     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
00897 }
00898 
00899 EventsNS::Message2::Message2(::Ice::Int __ice_id, ::Ice::Int __ice_i, ::Ice::Int __ice_j, const ::std::string& __ice_msg) :
00900 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00901     Event(__ice_id)
00902 #else
00903     ::EventsNS::Event(__ice_id)
00904 #endif
00905 ,
00906     i(__ice_i),
00907     j(__ice_j),
00908     msg(__ice_msg)
00909 {
00910 }
00911 
00912 ::Ice::ObjectPtr
00913 EventsNS::Message2::ice_clone() const
00914 {
00915     ::EventsNS::Message2Ptr __p = new ::EventsNS::Message2(*this);
00916     return __p;
00917 }
00918 
00919 static const ::std::string __EventsNS__Message2_ids[3] =
00920 {
00921     "::EventsNS::Event",
00922     "::EventsNS::Message2",
00923     "::Ice::Object"
00924 };
00925 
00926 bool
00927 EventsNS::Message2::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
00928 {
00929     return ::std::binary_search(__EventsNS__Message2_ids, __EventsNS__Message2_ids + 3, _s);
00930 }
00931 
00932 ::std::vector< ::std::string>
00933 EventsNS::Message2::ice_ids(const ::Ice::Current&) const
00934 {
00935     return ::std::vector< ::std::string>(&__EventsNS__Message2_ids[0], &__EventsNS__Message2_ids[3]);
00936 }
00937 
00938 const ::std::string&
00939 EventsNS::Message2::ice_id(const ::Ice::Current&) const
00940 {
00941     return __EventsNS__Message2_ids[1];
00942 }
00943 
00944 const ::std::string&
00945 EventsNS::Message2::ice_staticId()
00946 {
00947     return __EventsNS__Message2_ids[1];
00948 }
00949 
00950 void
00951 EventsNS::Message2::__write(::IceInternal::BasicStream* __os) const
00952 {
00953     __os->writeTypeId(ice_staticId());
00954     __os->startWriteSlice();
00955     __os->write(i);
00956     __os->write(j);
00957     __os->write(msg);
00958     __os->endWriteSlice();
00959 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00960     Event::__write(__os);
00961 #else
00962     ::EventsNS::Event::__write(__os);
00963 #endif
00964 }
00965 
00966 void
00967 EventsNS::Message2::__read(::IceInternal::BasicStream* __is, bool __rid)
00968 {
00969     if(__rid)
00970     {
00971         ::std::string myId;
00972         __is->readTypeId(myId);
00973     }
00974     __is->startReadSlice();
00975     __is->read(i);
00976     __is->read(j);
00977     __is->read(msg);
00978     __is->endReadSlice();
00979 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00980     Event::__read(__is, true);
00981 #else
00982     ::EventsNS::Event::__read(__is, true);
00983 #endif
00984 }
00985 
00986 void
00987 EventsNS::Message2::__write(const ::Ice::OutputStreamPtr&) const
00988 {
00989     Ice::MarshalException ex(__FILE__, __LINE__);
00990     ex.reason = "type EventsNS::Message2 was not generated with stream support";
00991     throw ex;
00992 }
00993 
00994 void
00995 EventsNS::Message2::__read(const ::Ice::InputStreamPtr&, bool)
00996 {
00997     Ice::MarshalException ex(__FILE__, __LINE__);
00998     ex.reason = "type EventsNS::Message2 was not generated with stream support";
00999     throw ex;
01000 }
01001 
01002 class __F__EventsNS__Message2 : public ::Ice::ObjectFactory
01003 {
01004 public:
01005 
01006     virtual ::Ice::ObjectPtr
01007     create(const ::std::string& type)
01008     {
01009         assert(type == ::EventsNS::Message2::ice_staticId());
01010         return new ::EventsNS::Message2;
01011     }
01012 
01013     virtual void
01014     destroy()
01015     {
01016     }
01017 };
01018 
01019 static ::Ice::ObjectFactoryPtr __F__EventsNS__Message2_Ptr = new __F__EventsNS__Message2;
01020 
01021 const ::Ice::ObjectFactoryPtr&
01022 EventsNS::Message2::ice_factory()
01023 {
01024     return __F__EventsNS__Message2_Ptr;
01025 }
01026 
01027 class __F__EventsNS__Message2__Init
01028 {
01029 public:
01030 
01031     __F__EventsNS__Message2__Init()
01032     {
01033         ::IceInternal::factoryTable->addObjectFactory(::EventsNS::Message2::ice_staticId(), ::EventsNS::Message2::ice_factory());
01034     }
01035 
01036     ~__F__EventsNS__Message2__Init()
01037     {
01038         ::IceInternal::factoryTable->removeObjectFactory(::EventsNS::Message2::ice_staticId());
01039     }
01040 };
01041 
01042 static __F__EventsNS__Message2__Init __F__EventsNS__Message2__i;
01043 
01044 #ifdef __APPLE__
01045 extern "C" { void __F__EventsNS__Message2__initializer() {} }
01046 #endif
01047 
01048 void
01049 EventsNS::__patch__Message2Ptr(void* __addr, ::Ice::ObjectPtr& v)
01050 {
01051     ::EventsNS::Message2Ptr* p = static_cast< ::EventsNS::Message2Ptr*>(__addr);
01052     assert(p);
01053     *p = ::EventsNS::Message2Ptr::dynamicCast(v);
01054     if(v && !*p)
01055     {
01056         IceInternal::Ex::throwUOE(::EventsNS::Message2::ice_staticId(), v->ice_id());
01057     }
01058 }
01059 
01060 bool
01061 EventsNS::operator==(const ::EventsNS::Message2& l, const ::EventsNS::Message2& r)
01062 {
01063     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01064 }
01065 
01066 bool
01067 EventsNS::operator<(const ::EventsNS::Message2& l, const ::EventsNS::Message2& r)
01068 {
01069     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01070 }
01071 
01072 ::Ice::ObjectPtr
01073 EventsNS::Events::ice_clone() const
01074 {
01075     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01076     return 0; // to avoid a warning with some compilers
01077 }
01078 
01079 static const ::std::string __EventsNS__Events_ids[2] =
01080 {
01081     "::EventsNS::Events",
01082     "::Ice::Object"
01083 };
01084 
01085 bool
01086 EventsNS::Events::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01087 {
01088     return ::std::binary_search(__EventsNS__Events_ids, __EventsNS__Events_ids + 2, _s);
01089 }
01090 
01091 ::std::vector< ::std::string>
01092 EventsNS::Events::ice_ids(const ::Ice::Current&) const
01093 {
01094     return ::std::vector< ::std::string>(&__EventsNS__Events_ids[0], &__EventsNS__Events_ids[2]);
01095 }
01096 
01097 const ::std::string&
01098 EventsNS::Events::ice_id(const ::Ice::Current&) const
01099 {
01100     return __EventsNS__Events_ids[0];
01101 }
01102 
01103 const ::std::string&
01104 EventsNS::Events::ice_staticId()
01105 {
01106     return __EventsNS__Events_ids[0];
01107 }
01108 
01109 ::Ice::DispatchStatus
01110 EventsNS::Events::___evolve(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
01111 {
01112     __checkMode(::Ice::Normal, __current.mode);
01113     ::IceInternal::BasicStream* __is = __inS.is();
01114     __is->startReadEncaps();
01115     ::EventsNS::EventPtr e;
01116     __is->read(::EventsNS::__patch__EventPtr, &e);
01117     __is->readPendingObjects();
01118     __is->endReadEncaps();
01119     evolve(e, __current);
01120     return ::Ice::DispatchOK;
01121 }
01122 
01123 static ::std::string __EventsNS__Events_all[] =
01124 {
01125     "evolve",
01126     "ice_id",
01127     "ice_ids",
01128     "ice_isA",
01129     "ice_ping"
01130 };
01131 
01132 ::Ice::DispatchStatus
01133 EventsNS::Events::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01134 {
01135     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__EventsNS__Events_all, __EventsNS__Events_all + 5, current.operation);
01136     if(r.first == r.second)
01137     {
01138         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01139     }
01140 
01141     switch(r.first - __EventsNS__Events_all)
01142     {
01143         case 0:
01144         {
01145             return ___evolve(in, current);
01146         }
01147         case 1:
01148         {
01149             return ___ice_id(in, current);
01150         }
01151         case 2:
01152         {
01153             return ___ice_ids(in, current);
01154         }
01155         case 3:
01156         {
01157             return ___ice_isA(in, current);
01158         }
01159         case 4:
01160         {
01161             return ___ice_ping(in, current);
01162         }
01163     }
01164 
01165     assert(false);
01166     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01167 }
01168 
01169 void
01170 EventsNS::Events::__write(::IceInternal::BasicStream* __os) const
01171 {
01172     __os->writeTypeId(ice_staticId());
01173     __os->startWriteSlice();
01174     __os->endWriteSlice();
01175 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01176     Object::__write(__os);
01177 #else
01178     ::Ice::Object::__write(__os);
01179 #endif
01180 }
01181 
01182 void
01183 EventsNS::Events::__read(::IceInternal::BasicStream* __is, bool __rid)
01184 {
01185     if(__rid)
01186     {
01187         ::std::string myId;
01188         __is->readTypeId(myId);
01189     }
01190     __is->startReadSlice();
01191     __is->endReadSlice();
01192 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01193     Object::__read(__is, true);
01194 #else
01195     ::Ice::Object::__read(__is, true);
01196 #endif
01197 }
01198 
01199 void
01200 EventsNS::Events::__write(const ::Ice::OutputStreamPtr&) const
01201 {
01202     Ice::MarshalException ex(__FILE__, __LINE__);
01203     ex.reason = "type EventsNS::Events was not generated with stream support";
01204     throw ex;
01205 }
01206 
01207 void
01208 EventsNS::Events::__read(const ::Ice::InputStreamPtr&, bool)
01209 {
01210     Ice::MarshalException ex(__FILE__, __LINE__);
01211     ex.reason = "type EventsNS::Events was not generated with stream support";
01212     throw ex;
01213 }
01214 
01215 void
01216 EventsNS::__patch__EventsPtr(void* __addr, ::Ice::ObjectPtr& v)
01217 {
01218     ::EventsNS::EventsPtr* p = static_cast< ::EventsNS::EventsPtr*>(__addr);
01219     assert(p);
01220     *p = ::EventsNS::EventsPtr::dynamicCast(v);
01221     if(v && !*p)
01222     {
01223         IceInternal::Ex::throwUOE(::EventsNS::Events::ice_staticId(), v->ice_id());
01224     }
01225 }
01226 
01227 bool
01228 EventsNS::operator==(const ::EventsNS::Events& l, const ::EventsNS::Events& r)
01229 {
01230     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01231 }
01232 
01233 bool
01234 EventsNS::operator<(const ::EventsNS::Events& l, const ::EventsNS::Events& r)
01235 {
01236     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01237 }
01238 
01239 ::Ice::ObjectPtr
01240 TestPub::Publisher1::ice_clone() const
01241 {
01242     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01243     return 0; // to avoid a warning with some compilers
01244 }
01245 
01246 static const ::std::string __TestPub__Publisher1_ids[3] =
01247 {
01248     "::EventsNS::Events",
01249     "::Ice::Object",
01250     "::TestPub::Publisher1"
01251 };
01252 
01253 bool
01254 TestPub::Publisher1::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01255 {
01256     return ::std::binary_search(__TestPub__Publisher1_ids, __TestPub__Publisher1_ids + 3, _s);
01257 }
01258 
01259 ::std::vector< ::std::string>
01260 TestPub::Publisher1::ice_ids(const ::Ice::Current&) const
01261 {
01262     return ::std::vector< ::std::string>(&__TestPub__Publisher1_ids[0], &__TestPub__Publisher1_ids[3]);
01263 }
01264 
01265 const ::std::string&
01266 TestPub::Publisher1::ice_id(const ::Ice::Current&) const
01267 {
01268     return __TestPub__Publisher1_ids[2];
01269 }
01270 
01271 const ::std::string&
01272 TestPub::Publisher1::ice_staticId()
01273 {
01274     return __TestPub__Publisher1_ids[2];
01275 }
01276 
01277 static ::std::string __TestPub__Publisher1_all[] =
01278 {
01279     "evolve",
01280     "ice_id",
01281     "ice_ids",
01282     "ice_isA",
01283     "ice_ping"
01284 };
01285 
01286 ::Ice::DispatchStatus
01287 TestPub::Publisher1::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01288 {
01289     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Publisher1_all, __TestPub__Publisher1_all + 5, current.operation);
01290     if(r.first == r.second)
01291     {
01292         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01293     }
01294 
01295     switch(r.first - __TestPub__Publisher1_all)
01296     {
01297         case 0:
01298         {
01299             return ___evolve(in, current);
01300         }
01301         case 1:
01302         {
01303             return ___ice_id(in, current);
01304         }
01305         case 2:
01306         {
01307             return ___ice_ids(in, current);
01308         }
01309         case 3:
01310         {
01311             return ___ice_isA(in, current);
01312         }
01313         case 4:
01314         {
01315             return ___ice_ping(in, current);
01316         }
01317     }
01318 
01319     assert(false);
01320     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01321 }
01322 
01323 void
01324 TestPub::Publisher1::__write(::IceInternal::BasicStream* __os) const
01325 {
01326     __os->writeTypeId(ice_staticId());
01327     __os->startWriteSlice();
01328     __os->endWriteSlice();
01329 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01330     Object::__write(__os);
01331 #else
01332     ::Ice::Object::__write(__os);
01333 #endif
01334 }
01335 
01336 void
01337 TestPub::Publisher1::__read(::IceInternal::BasicStream* __is, bool __rid)
01338 {
01339     if(__rid)
01340     {
01341         ::std::string myId;
01342         __is->readTypeId(myId);
01343     }
01344     __is->startReadSlice();
01345     __is->endReadSlice();
01346 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01347     Object::__read(__is, true);
01348 #else
01349     ::Ice::Object::__read(__is, true);
01350 #endif
01351 }
01352 
01353 void
01354 TestPub::Publisher1::__write(const ::Ice::OutputStreamPtr&) const
01355 {
01356     Ice::MarshalException ex(__FILE__, __LINE__);
01357     ex.reason = "type TestPub::Publisher1 was not generated with stream support";
01358     throw ex;
01359 }
01360 
01361 void
01362 TestPub::Publisher1::__read(const ::Ice::InputStreamPtr&, bool)
01363 {
01364     Ice::MarshalException ex(__FILE__, __LINE__);
01365     ex.reason = "type TestPub::Publisher1 was not generated with stream support";
01366     throw ex;
01367 }
01368 
01369 void
01370 TestPub::__patch__Publisher1Ptr(void* __addr, ::Ice::ObjectPtr& v)
01371 {
01372     ::TestPub::Publisher1Ptr* p = static_cast< ::TestPub::Publisher1Ptr*>(__addr);
01373     assert(p);
01374     *p = ::TestPub::Publisher1Ptr::dynamicCast(v);
01375     if(v && !*p)
01376     {
01377         IceInternal::Ex::throwUOE(::TestPub::Publisher1::ice_staticId(), v->ice_id());
01378     }
01379 }
01380 
01381 bool
01382 TestPub::operator==(const ::TestPub::Publisher1& l, const ::TestPub::Publisher1& r)
01383 {
01384     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01385 }
01386 
01387 bool
01388 TestPub::operator<(const ::TestPub::Publisher1& l, const ::TestPub::Publisher1& r)
01389 {
01390     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01391 }
01392 
01393 ::Ice::ObjectPtr
01394 TestPub::Publisher2::ice_clone() const
01395 {
01396     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01397     return 0; // to avoid a warning with some compilers
01398 }
01399 
01400 static const ::std::string __TestPub__Publisher2_ids[3] =
01401 {
01402     "::EventsNS::Events",
01403     "::Ice::Object",
01404     "::TestPub::Publisher2"
01405 };
01406 
01407 bool
01408 TestPub::Publisher2::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01409 {
01410     return ::std::binary_search(__TestPub__Publisher2_ids, __TestPub__Publisher2_ids + 3, _s);
01411 }
01412 
01413 ::std::vector< ::std::string>
01414 TestPub::Publisher2::ice_ids(const ::Ice::Current&) const
01415 {
01416     return ::std::vector< ::std::string>(&__TestPub__Publisher2_ids[0], &__TestPub__Publisher2_ids[3]);
01417 }
01418 
01419 const ::std::string&
01420 TestPub::Publisher2::ice_id(const ::Ice::Current&) const
01421 {
01422     return __TestPub__Publisher2_ids[2];
01423 }
01424 
01425 const ::std::string&
01426 TestPub::Publisher2::ice_staticId()
01427 {
01428     return __TestPub__Publisher2_ids[2];
01429 }
01430 
01431 static ::std::string __TestPub__Publisher2_all[] =
01432 {
01433     "evolve",
01434     "ice_id",
01435     "ice_ids",
01436     "ice_isA",
01437     "ice_ping"
01438 };
01439 
01440 ::Ice::DispatchStatus
01441 TestPub::Publisher2::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01442 {
01443     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Publisher2_all, __TestPub__Publisher2_all + 5, current.operation);
01444     if(r.first == r.second)
01445     {
01446         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01447     }
01448 
01449     switch(r.first - __TestPub__Publisher2_all)
01450     {
01451         case 0:
01452         {
01453             return ___evolve(in, current);
01454         }
01455         case 1:
01456         {
01457             return ___ice_id(in, current);
01458         }
01459         case 2:
01460         {
01461             return ___ice_ids(in, current);
01462         }
01463         case 3:
01464         {
01465             return ___ice_isA(in, current);
01466         }
01467         case 4:
01468         {
01469             return ___ice_ping(in, current);
01470         }
01471     }
01472 
01473     assert(false);
01474     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01475 }
01476 
01477 void
01478 TestPub::Publisher2::__write(::IceInternal::BasicStream* __os) const
01479 {
01480     __os->writeTypeId(ice_staticId());
01481     __os->startWriteSlice();
01482     __os->endWriteSlice();
01483 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01484     Object::__write(__os);
01485 #else
01486     ::Ice::Object::__write(__os);
01487 #endif
01488 }
01489 
01490 void
01491 TestPub::Publisher2::__read(::IceInternal::BasicStream* __is, bool __rid)
01492 {
01493     if(__rid)
01494     {
01495         ::std::string myId;
01496         __is->readTypeId(myId);
01497     }
01498     __is->startReadSlice();
01499     __is->endReadSlice();
01500 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01501     Object::__read(__is, true);
01502 #else
01503     ::Ice::Object::__read(__is, true);
01504 #endif
01505 }
01506 
01507 void
01508 TestPub::Publisher2::__write(const ::Ice::OutputStreamPtr&) const
01509 {
01510     Ice::MarshalException ex(__FILE__, __LINE__);
01511     ex.reason = "type TestPub::Publisher2 was not generated with stream support";
01512     throw ex;
01513 }
01514 
01515 void
01516 TestPub::Publisher2::__read(const ::Ice::InputStreamPtr&, bool)
01517 {
01518     Ice::MarshalException ex(__FILE__, __LINE__);
01519     ex.reason = "type TestPub::Publisher2 was not generated with stream support";
01520     throw ex;
01521 }
01522 
01523 void
01524 TestPub::__patch__Publisher2Ptr(void* __addr, ::Ice::ObjectPtr& v)
01525 {
01526     ::TestPub::Publisher2Ptr* p = static_cast< ::TestPub::Publisher2Ptr*>(__addr);
01527     assert(p);
01528     *p = ::TestPub::Publisher2Ptr::dynamicCast(v);
01529     if(v && !*p)
01530     {
01531         IceInternal::Ex::throwUOE(::TestPub::Publisher2::ice_staticId(), v->ice_id());
01532     }
01533 }
01534 
01535 bool
01536 TestPub::operator==(const ::TestPub::Publisher2& l, const ::TestPub::Publisher2& r)
01537 {
01538     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01539 }
01540 
01541 bool
01542 TestPub::operator<(const ::TestPub::Publisher2& l, const ::TestPub::Publisher2& r)
01543 {
01544     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01545 }
01546 
01547 ::Ice::ObjectPtr
01548 TestPub::Subscriber1::ice_clone() const
01549 {
01550     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01551     return 0; // to avoid a warning with some compilers
01552 }
01553 
01554 static const ::std::string __TestPub__Subscriber1_ids[3] =
01555 {
01556     "::EventsNS::Events",
01557     "::Ice::Object",
01558     "::TestPub::Subscriber1"
01559 };
01560 
01561 bool
01562 TestPub::Subscriber1::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01563 {
01564     return ::std::binary_search(__TestPub__Subscriber1_ids, __TestPub__Subscriber1_ids + 3, _s);
01565 }
01566 
01567 ::std::vector< ::std::string>
01568 TestPub::Subscriber1::ice_ids(const ::Ice::Current&) const
01569 {
01570     return ::std::vector< ::std::string>(&__TestPub__Subscriber1_ids[0], &__TestPub__Subscriber1_ids[3]);
01571 }
01572 
01573 const ::std::string&
01574 TestPub::Subscriber1::ice_id(const ::Ice::Current&) const
01575 {
01576     return __TestPub__Subscriber1_ids[2];
01577 }
01578 
01579 const ::std::string&
01580 TestPub::Subscriber1::ice_staticId()
01581 {
01582     return __TestPub__Subscriber1_ids[2];
01583 }
01584 
01585 static ::std::string __TestPub__Subscriber1_all[] =
01586 {
01587     "evolve",
01588     "ice_id",
01589     "ice_ids",
01590     "ice_isA",
01591     "ice_ping"
01592 };
01593 
01594 ::Ice::DispatchStatus
01595 TestPub::Subscriber1::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01596 {
01597     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Subscriber1_all, __TestPub__Subscriber1_all + 5, current.operation);
01598     if(r.first == r.second)
01599     {
01600         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01601     }
01602 
01603     switch(r.first - __TestPub__Subscriber1_all)
01604     {
01605         case 0:
01606         {
01607             return ___evolve(in, current);
01608         }
01609         case 1:
01610         {
01611             return ___ice_id(in, current);
01612         }
01613         case 2:
01614         {
01615             return ___ice_ids(in, current);
01616         }
01617         case 3:
01618         {
01619             return ___ice_isA(in, current);
01620         }
01621         case 4:
01622         {
01623             return ___ice_ping(in, current);
01624         }
01625     }
01626 
01627     assert(false);
01628     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01629 }
01630 
01631 void
01632 TestPub::Subscriber1::__write(::IceInternal::BasicStream* __os) const
01633 {
01634     __os->writeTypeId(ice_staticId());
01635     __os->startWriteSlice();
01636     __os->endWriteSlice();
01637 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01638     Object::__write(__os);
01639 #else
01640     ::Ice::Object::__write(__os);
01641 #endif
01642 }
01643 
01644 void
01645 TestPub::Subscriber1::__read(::IceInternal::BasicStream* __is, bool __rid)
01646 {
01647     if(__rid)
01648     {
01649         ::std::string myId;
01650         __is->readTypeId(myId);
01651     }
01652     __is->startReadSlice();
01653     __is->endReadSlice();
01654 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01655     Object::__read(__is, true);
01656 #else
01657     ::Ice::Object::__read(__is, true);
01658 #endif
01659 }
01660 
01661 void
01662 TestPub::Subscriber1::__write(const ::Ice::OutputStreamPtr&) const
01663 {
01664     Ice::MarshalException ex(__FILE__, __LINE__);
01665     ex.reason = "type TestPub::Subscriber1 was not generated with stream support";
01666     throw ex;
01667 }
01668 
01669 void
01670 TestPub::Subscriber1::__read(const ::Ice::InputStreamPtr&, bool)
01671 {
01672     Ice::MarshalException ex(__FILE__, __LINE__);
01673     ex.reason = "type TestPub::Subscriber1 was not generated with stream support";
01674     throw ex;
01675 }
01676 
01677 void
01678 TestPub::__patch__Subscriber1Ptr(void* __addr, ::Ice::ObjectPtr& v)
01679 {
01680     ::TestPub::Subscriber1Ptr* p = static_cast< ::TestPub::Subscriber1Ptr*>(__addr);
01681     assert(p);
01682     *p = ::TestPub::Subscriber1Ptr::dynamicCast(v);
01683     if(v && !*p)
01684     {
01685         IceInternal::Ex::throwUOE(::TestPub::Subscriber1::ice_staticId(), v->ice_id());
01686     }
01687 }
01688 
01689 bool
01690 TestPub::operator==(const ::TestPub::Subscriber1& l, const ::TestPub::Subscriber1& r)
01691 {
01692     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01693 }
01694 
01695 bool
01696 TestPub::operator<(const ::TestPub::Subscriber1& l, const ::TestPub::Subscriber1& r)
01697 {
01698     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01699 }
01700 
01701 ::Ice::ObjectPtr
01702 TestPub::Subscriber2::ice_clone() const
01703 {
01704     throw ::Ice::CloneNotImplementedException(__FILE__, __LINE__);
01705     return 0; // to avoid a warning with some compilers
01706 }
01707 
01708 static const ::std::string __TestPub__Subscriber2_ids[3] =
01709 {
01710     "::EventsNS::Events",
01711     "::Ice::Object",
01712     "::TestPub::Subscriber2"
01713 };
01714 
01715 bool
01716 TestPub::Subscriber2::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
01717 {
01718     return ::std::binary_search(__TestPub__Subscriber2_ids, __TestPub__Subscriber2_ids + 3, _s);
01719 }
01720 
01721 ::std::vector< ::std::string>
01722 TestPub::Subscriber2::ice_ids(const ::Ice::Current&) const
01723 {
01724     return ::std::vector< ::std::string>(&__TestPub__Subscriber2_ids[0], &__TestPub__Subscriber2_ids[3]);
01725 }
01726 
01727 const ::std::string&
01728 TestPub::Subscriber2::ice_id(const ::Ice::Current&) const
01729 {
01730     return __TestPub__Subscriber2_ids[2];
01731 }
01732 
01733 const ::std::string&
01734 TestPub::Subscriber2::ice_staticId()
01735 {
01736     return __TestPub__Subscriber2_ids[2];
01737 }
01738 
01739 static ::std::string __TestPub__Subscriber2_all[] =
01740 {
01741     "evolve",
01742     "ice_id",
01743     "ice_ids",
01744     "ice_isA",
01745     "ice_ping"
01746 };
01747 
01748 ::Ice::DispatchStatus
01749 TestPub::Subscriber2::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
01750 {
01751     ::std::pair< ::std::string*, ::std::string*> r = ::std::equal_range(__TestPub__Subscriber2_all, __TestPub__Subscriber2_all + 5, current.operation);
01752     if(r.first == r.second)
01753     {
01754         throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01755     }
01756 
01757     switch(r.first - __TestPub__Subscriber2_all)
01758     {
01759         case 0:
01760         {
01761             return ___evolve(in, current);
01762         }
01763         case 1:
01764         {
01765             return ___ice_id(in, current);
01766         }
01767         case 2:
01768         {
01769             return ___ice_ids(in, current);
01770         }
01771         case 3:
01772         {
01773             return ___ice_isA(in, current);
01774         }
01775         case 4:
01776         {
01777             return ___ice_ping(in, current);
01778         }
01779     }
01780 
01781     assert(false);
01782     throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
01783 }
01784 
01785 void
01786 TestPub::Subscriber2::__write(::IceInternal::BasicStream* __os) const
01787 {
01788     __os->writeTypeId(ice_staticId());
01789     __os->startWriteSlice();
01790     __os->endWriteSlice();
01791 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01792     Object::__write(__os);
01793 #else
01794     ::Ice::Object::__write(__os);
01795 #endif
01796 }
01797 
01798 void
01799 TestPub::Subscriber2::__read(::IceInternal::BasicStream* __is, bool __rid)
01800 {
01801     if(__rid)
01802     {
01803         ::std::string myId;
01804         __is->readTypeId(myId);
01805     }
01806     __is->startReadSlice();
01807     __is->endReadSlice();
01808 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01809     Object::__read(__is, true);
01810 #else
01811     ::Ice::Object::__read(__is, true);
01812 #endif
01813 }
01814 
01815 void
01816 TestPub::Subscriber2::__write(const ::Ice::OutputStreamPtr&) const
01817 {
01818     Ice::MarshalException ex(__FILE__, __LINE__);
01819     ex.reason = "type TestPub::Subscriber2 was not generated with stream support";
01820     throw ex;
01821 }
01822 
01823 void
01824 TestPub::Subscriber2::__read(const ::Ice::InputStreamPtr&, bool)
01825 {
01826     Ice::MarshalException ex(__FILE__, __LINE__);
01827     ex.reason = "type TestPub::Subscriber2 was not generated with stream support";
01828     throw ex;
01829 }
01830 
01831 void
01832 TestPub::__patch__Subscriber2Ptr(void* __addr, ::Ice::ObjectPtr& v)
01833 {
01834     ::TestPub::Subscriber2Ptr* p = static_cast< ::TestPub::Subscriber2Ptr*>(__addr);
01835     assert(p);
01836     *p = ::TestPub::Subscriber2Ptr::dynamicCast(v);
01837     if(v && !*p)
01838     {
01839         IceInternal::Ex::throwUOE(::TestPub::Subscriber2::ice_staticId(), v->ice_id());
01840     }
01841 }
01842 
01843 bool
01844 TestPub::operator==(const ::TestPub::Subscriber2& l, const ::TestPub::Subscriber2& r)
01845 {
01846     return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
01847 }
01848 
01849 bool
01850 TestPub::operator<(const ::TestPub::Subscriber2& l, const ::TestPub::Subscriber2& r)
01851 {
01852     return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
01853 }
Generated on Sun May 8 08:40:44 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3