Events.ice.H

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 #ifndef __src_Ice_IceStorm__Events_ice_H__
00014 #define __src_Ice_IceStorm__Events_ice_H__
00015 
00016 #include <Ice/LocalObjectF.h>
00017 #include <Ice/ProxyF.h>
00018 #include <Ice/ObjectF.h>
00019 #include <Ice/Exception.h>
00020 #include <Ice/LocalObject.h>
00021 #include <Ice/Proxy.h>
00022 #include <Ice/Object.h>
00023 #include <Ice/Outgoing.h>
00024 #include <Ice/OutgoingAsync.h>
00025 #include <Ice/Incoming.h>
00026 #include <Ice/Direct.h>
00027 #include <Ice/FactoryTable.h>
00028 #include <Ice/StreamF.h>
00029 #include <Ice/UndefSysMacros.h>
00030 
00031 #ifndef ICE_IGNORE_VERSION
00032 #   if ICE_INT_VERSION / 100 != 303
00033 #       error Ice version mismatch!
00034 #   endif
00035 #   if ICE_INT_VERSION % 100 > 50
00036 #       error Beta header file detected
00037 #   endif
00038 #   if ICE_INT_VERSION % 100 < 1
00039 #       error Ice patch level mismatch!
00040 #   endif
00041 #endif
00042 
00043 namespace IceProxy
00044 {
00045 
00046 namespace EventsNS
00047 {
00048 
00049 class Event;
00050 
00051 class Message1;
00052 
00053 class Message2;
00054 
00055 class Events;
00056 
00057 }
00058 
00059 namespace TestPub
00060 {
00061 
00062 class Publisher1;
00063 
00064 class Publisher2;
00065 
00066 class Subscriber1;
00067 
00068 class Subscriber2;
00069 
00070 }
00071 
00072 }
00073 
00074 namespace EventsNS
00075 {
00076 
00077 class Event;
00078 bool operator==(const Event&, const Event&);
00079 bool operator<(const Event&, const Event&);
00080 
00081 class Message1;
00082 bool operator==(const Message1&, const Message1&);
00083 bool operator<(const Message1&, const Message1&);
00084 
00085 class Message2;
00086 bool operator==(const Message2&, const Message2&);
00087 bool operator<(const Message2&, const Message2&);
00088 
00089 class Events;
00090 bool operator==(const Events&, const Events&);
00091 bool operator<(const Events&, const Events&);
00092 
00093 }
00094 
00095 namespace TestPub
00096 {
00097 
00098 class Publisher1;
00099 bool operator==(const Publisher1&, const Publisher1&);
00100 bool operator<(const Publisher1&, const Publisher1&);
00101 
00102 class Publisher2;
00103 bool operator==(const Publisher2&, const Publisher2&);
00104 bool operator<(const Publisher2&, const Publisher2&);
00105 
00106 class Subscriber1;
00107 bool operator==(const Subscriber1&, const Subscriber1&);
00108 bool operator<(const Subscriber1&, const Subscriber1&);
00109 
00110 class Subscriber2;
00111 bool operator==(const Subscriber2&, const Subscriber2&);
00112 bool operator<(const Subscriber2&, const Subscriber2&);
00113 
00114 }
00115 
00116 namespace IceInternal
00117 {
00118 
00119 ::Ice::Object* upCast(::EventsNS::Event*);
00120 ::IceProxy::Ice::Object* upCast(::IceProxy::EventsNS::Event*);
00121 
00122 ::Ice::Object* upCast(::EventsNS::Message1*);
00123 ::IceProxy::Ice::Object* upCast(::IceProxy::EventsNS::Message1*);
00124 
00125 ::Ice::Object* upCast(::EventsNS::Message2*);
00126 ::IceProxy::Ice::Object* upCast(::IceProxy::EventsNS::Message2*);
00127 
00128 ::Ice::Object* upCast(::EventsNS::Events*);
00129 ::IceProxy::Ice::Object* upCast(::IceProxy::EventsNS::Events*);
00130 
00131 ::Ice::Object* upCast(::TestPub::Publisher1*);
00132 ::IceProxy::Ice::Object* upCast(::IceProxy::TestPub::Publisher1*);
00133 
00134 ::Ice::Object* upCast(::TestPub::Publisher2*);
00135 ::IceProxy::Ice::Object* upCast(::IceProxy::TestPub::Publisher2*);
00136 
00137 ::Ice::Object* upCast(::TestPub::Subscriber1*);
00138 ::IceProxy::Ice::Object* upCast(::IceProxy::TestPub::Subscriber1*);
00139 
00140 ::Ice::Object* upCast(::TestPub::Subscriber2*);
00141 ::IceProxy::Ice::Object* upCast(::IceProxy::TestPub::Subscriber2*);
00142 
00143 }
00144 
00145 namespace EventsNS
00146 {
00147 
00148 typedef ::IceInternal::Handle< ::EventsNS::Event> EventPtr;
00149 typedef ::IceInternal::ProxyHandle< ::IceProxy::EventsNS::Event> EventPrx;
00150 
00151 void __read(::IceInternal::BasicStream*, EventPrx&);
00152 void __patch__EventPtr(void*, ::Ice::ObjectPtr&);
00153 
00154 typedef ::IceInternal::Handle< ::EventsNS::Message1> Message1Ptr;
00155 typedef ::IceInternal::ProxyHandle< ::IceProxy::EventsNS::Message1> Message1Prx;
00156 
00157 void __read(::IceInternal::BasicStream*, Message1Prx&);
00158 void __patch__Message1Ptr(void*, ::Ice::ObjectPtr&);
00159 
00160 typedef ::IceInternal::Handle< ::EventsNS::Message2> Message2Ptr;
00161 typedef ::IceInternal::ProxyHandle< ::IceProxy::EventsNS::Message2> Message2Prx;
00162 
00163 void __read(::IceInternal::BasicStream*, Message2Prx&);
00164 void __patch__Message2Ptr(void*, ::Ice::ObjectPtr&);
00165 
00166 typedef ::IceInternal::Handle< ::EventsNS::Events> EventsPtr;
00167 typedef ::IceInternal::ProxyHandle< ::IceProxy::EventsNS::Events> EventsPrx;
00168 
00169 void __read(::IceInternal::BasicStream*, EventsPrx&);
00170 void __patch__EventsPtr(void*, ::Ice::ObjectPtr&);
00171 
00172 }
00173 
00174 namespace TestPub
00175 {
00176 
00177 typedef ::IceInternal::Handle< ::TestPub::Publisher1> Publisher1Ptr;
00178 typedef ::IceInternal::ProxyHandle< ::IceProxy::TestPub::Publisher1> Publisher1Prx;
00179 
00180 void __read(::IceInternal::BasicStream*, Publisher1Prx&);
00181 void __patch__Publisher1Ptr(void*, ::Ice::ObjectPtr&);
00182 
00183 typedef ::IceInternal::Handle< ::TestPub::Publisher2> Publisher2Ptr;
00184 typedef ::IceInternal::ProxyHandle< ::IceProxy::TestPub::Publisher2> Publisher2Prx;
00185 
00186 void __read(::IceInternal::BasicStream*, Publisher2Prx&);
00187 void __patch__Publisher2Ptr(void*, ::Ice::ObjectPtr&);
00188 
00189 typedef ::IceInternal::Handle< ::TestPub::Subscriber1> Subscriber1Ptr;
00190 typedef ::IceInternal::ProxyHandle< ::IceProxy::TestPub::Subscriber1> Subscriber1Prx;
00191 
00192 void __read(::IceInternal::BasicStream*, Subscriber1Prx&);
00193 void __patch__Subscriber1Ptr(void*, ::Ice::ObjectPtr&);
00194 
00195 typedef ::IceInternal::Handle< ::TestPub::Subscriber2> Subscriber2Ptr;
00196 typedef ::IceInternal::ProxyHandle< ::IceProxy::TestPub::Subscriber2> Subscriber2Prx;
00197 
00198 void __read(::IceInternal::BasicStream*, Subscriber2Prx&);
00199 void __patch__Subscriber2Ptr(void*, ::Ice::ObjectPtr&);
00200 
00201 }
00202 
00203 namespace EventsNS
00204 {
00205 
00206 class AMI_Events_evolve : public ::IceInternal::OutgoingAsync
00207 {
00208 public:
00209 
00210     virtual void ice_response() = 0;
00211     virtual void ice_exception(const ::Ice::Exception&) = 0;
00212 
00213     bool __invoke(const ::EventsNS::EventsPrx&, const ::EventsNS::EventPtr&, const ::Ice::Context*);
00214 
00215 protected:
00216 
00217     virtual void __response(bool);
00218 };
00219 
00220 typedef ::IceUtil::Handle< ::EventsNS::AMI_Events_evolve> AMI_Events_evolvePtr;
00221 
00222 }
00223 
00224 namespace IceProxy
00225 {
00226 
00227 namespace EventsNS
00228 {
00229 
00230 class Event : virtual public ::IceProxy::Ice::Object
00231 {
00232 public:
00233 
00234     ::IceInternal::ProxyHandle<Event> ice_context(const ::Ice::Context& __context) const
00235     {
00236     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00237         typedef ::IceProxy::Ice::Object _Base;
00238         return dynamic_cast<Event*>(_Base::ice_context(__context).get());
00239     #else
00240         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_context(__context).get());
00241     #endif
00242     }
00243 
00244     ::IceInternal::ProxyHandle<Event> ice_adapterId(const std::string& __id) const
00245     {
00246     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00247         typedef ::IceProxy::Ice::Object _Base;
00248         return dynamic_cast<Event*>(_Base::ice_adapterId(__id).get());
00249     #else
00250         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00251     #endif
00252     }
00253 
00254     ::IceInternal::ProxyHandle<Event> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00255     {
00256     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00257         typedef ::IceProxy::Ice::Object _Base;
00258         return dynamic_cast<Event*>(_Base::ice_endpoints(__endpoints).get());
00259     #else
00260         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00261     #endif
00262     }
00263 
00264     ::IceInternal::ProxyHandle<Event> ice_locatorCacheTimeout(int __timeout) const
00265     {
00266     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00267         typedef ::IceProxy::Ice::Object _Base;
00268         return dynamic_cast<Event*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00269     #else
00270         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00271     #endif
00272     }
00273 
00274     ::IceInternal::ProxyHandle<Event> ice_connectionCached(bool __cached) const
00275     {
00276     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00277         typedef ::IceProxy::Ice::Object _Base;
00278         return dynamic_cast<Event*>(_Base::ice_connectionCached(__cached).get());
00279     #else
00280         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00281     #endif
00282     }
00283 
00284     ::IceInternal::ProxyHandle<Event> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00285     {
00286     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00287         typedef ::IceProxy::Ice::Object _Base;
00288         return dynamic_cast<Event*>(_Base::ice_endpointSelection(__est).get());
00289     #else
00290         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00291     #endif
00292     }
00293 
00294     ::IceInternal::ProxyHandle<Event> ice_secure(bool __secure) const
00295     {
00296     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00297         typedef ::IceProxy::Ice::Object _Base;
00298         return dynamic_cast<Event*>(_Base::ice_secure(__secure).get());
00299     #else
00300         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00301     #endif
00302     }
00303 
00304     ::IceInternal::ProxyHandle<Event> ice_preferSecure(bool __preferSecure) const
00305     {
00306     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00307         typedef ::IceProxy::Ice::Object _Base;
00308         return dynamic_cast<Event*>(_Base::ice_preferSecure(__preferSecure).get());
00309     #else
00310         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00311     #endif
00312     }
00313 
00314     ::IceInternal::ProxyHandle<Event> ice_router(const ::Ice::RouterPrx& __router) const
00315     {
00316     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00317         typedef ::IceProxy::Ice::Object _Base;
00318         return dynamic_cast<Event*>(_Base::ice_router(__router).get());
00319     #else
00320         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_router(__router).get());
00321     #endif
00322     }
00323 
00324     ::IceInternal::ProxyHandle<Event> ice_locator(const ::Ice::LocatorPrx& __locator) const
00325     {
00326     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00327         typedef ::IceProxy::Ice::Object _Base;
00328         return dynamic_cast<Event*>(_Base::ice_locator(__locator).get());
00329     #else
00330         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00331     #endif
00332     }
00333 
00334     ::IceInternal::ProxyHandle<Event> ice_collocationOptimized(bool __co) const
00335     {
00336     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00337         typedef ::IceProxy::Ice::Object _Base;
00338         return dynamic_cast<Event*>(_Base::ice_collocationOptimized(__co).get());
00339     #else
00340         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00341     #endif
00342     }
00343 
00344     ::IceInternal::ProxyHandle<Event> ice_twoway() const
00345     {
00346     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00347         typedef ::IceProxy::Ice::Object _Base;
00348         return dynamic_cast<Event*>(_Base::ice_twoway().get());
00349     #else
00350         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_twoway().get());
00351     #endif
00352     }
00353 
00354     ::IceInternal::ProxyHandle<Event> ice_oneway() const
00355     {
00356     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00357         typedef ::IceProxy::Ice::Object _Base;
00358         return dynamic_cast<Event*>(_Base::ice_oneway().get());
00359     #else
00360         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_oneway().get());
00361     #endif
00362     }
00363 
00364     ::IceInternal::ProxyHandle<Event> ice_batchOneway() const
00365     {
00366     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00367         typedef ::IceProxy::Ice::Object _Base;
00368         return dynamic_cast<Event*>(_Base::ice_batchOneway().get());
00369     #else
00370         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00371     #endif
00372     }
00373 
00374     ::IceInternal::ProxyHandle<Event> ice_datagram() const
00375     {
00376     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00377         typedef ::IceProxy::Ice::Object _Base;
00378         return dynamic_cast<Event*>(_Base::ice_datagram().get());
00379     #else
00380         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_datagram().get());
00381     #endif
00382     }
00383 
00384     ::IceInternal::ProxyHandle<Event> ice_batchDatagram() const
00385     {
00386     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00387         typedef ::IceProxy::Ice::Object _Base;
00388         return dynamic_cast<Event*>(_Base::ice_batchDatagram().get());
00389     #else
00390         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00391     #endif
00392     }
00393 
00394     ::IceInternal::ProxyHandle<Event> ice_compress(bool __compress) const
00395     {
00396     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00397         typedef ::IceProxy::Ice::Object _Base;
00398         return dynamic_cast<Event*>(_Base::ice_compress(__compress).get());
00399     #else
00400         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00401     #endif
00402     }
00403 
00404     ::IceInternal::ProxyHandle<Event> ice_timeout(int __timeout) const
00405     {
00406     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00407         typedef ::IceProxy::Ice::Object _Base;
00408         return dynamic_cast<Event*>(_Base::ice_timeout(__timeout).get());
00409     #else
00410         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00411     #endif
00412     }
00413 
00414     ::IceInternal::ProxyHandle<Event> ice_connectionId(const std::string& __id) const
00415     {
00416     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00417         typedef ::IceProxy::Ice::Object _Base;
00418         return dynamic_cast<Event*>(_Base::ice_connectionId(__id).get());
00419     #else
00420         return dynamic_cast<Event*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00421     #endif
00422     }
00423 
00424     static const ::std::string& ice_staticId();
00425 
00426 private:
00427 
00428     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00429     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00430     virtual ::IceProxy::Ice::Object* __newInstance() const;
00431 };
00432 
00433 class Message1 : virtual public ::IceProxy::EventsNS::Event
00434 {
00435 public:
00436 
00437     ::IceInternal::ProxyHandle<Message1> ice_context(const ::Ice::Context& __context) const
00438     {
00439     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00440         typedef ::IceProxy::Ice::Object _Base;
00441         return dynamic_cast<Message1*>(_Base::ice_context(__context).get());
00442     #else
00443         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_context(__context).get());
00444     #endif
00445     }
00446 
00447     ::IceInternal::ProxyHandle<Message1> ice_adapterId(const std::string& __id) const
00448     {
00449     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00450         typedef ::IceProxy::Ice::Object _Base;
00451         return dynamic_cast<Message1*>(_Base::ice_adapterId(__id).get());
00452     #else
00453         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00454     #endif
00455     }
00456 
00457     ::IceInternal::ProxyHandle<Message1> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00458     {
00459     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00460         typedef ::IceProxy::Ice::Object _Base;
00461         return dynamic_cast<Message1*>(_Base::ice_endpoints(__endpoints).get());
00462     #else
00463         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00464     #endif
00465     }
00466 
00467     ::IceInternal::ProxyHandle<Message1> ice_locatorCacheTimeout(int __timeout) const
00468     {
00469     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00470         typedef ::IceProxy::Ice::Object _Base;
00471         return dynamic_cast<Message1*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00472     #else
00473         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00474     #endif
00475     }
00476 
00477     ::IceInternal::ProxyHandle<Message1> ice_connectionCached(bool __cached) const
00478     {
00479     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00480         typedef ::IceProxy::Ice::Object _Base;
00481         return dynamic_cast<Message1*>(_Base::ice_connectionCached(__cached).get());
00482     #else
00483         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00484     #endif
00485     }
00486 
00487     ::IceInternal::ProxyHandle<Message1> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00488     {
00489     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00490         typedef ::IceProxy::Ice::Object _Base;
00491         return dynamic_cast<Message1*>(_Base::ice_endpointSelection(__est).get());
00492     #else
00493         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00494     #endif
00495     }
00496 
00497     ::IceInternal::ProxyHandle<Message1> ice_secure(bool __secure) const
00498     {
00499     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00500         typedef ::IceProxy::Ice::Object _Base;
00501         return dynamic_cast<Message1*>(_Base::ice_secure(__secure).get());
00502     #else
00503         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00504     #endif
00505     }
00506 
00507     ::IceInternal::ProxyHandle<Message1> ice_preferSecure(bool __preferSecure) const
00508     {
00509     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00510         typedef ::IceProxy::Ice::Object _Base;
00511         return dynamic_cast<Message1*>(_Base::ice_preferSecure(__preferSecure).get());
00512     #else
00513         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00514     #endif
00515     }
00516 
00517     ::IceInternal::ProxyHandle<Message1> ice_router(const ::Ice::RouterPrx& __router) const
00518     {
00519     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00520         typedef ::IceProxy::Ice::Object _Base;
00521         return dynamic_cast<Message1*>(_Base::ice_router(__router).get());
00522     #else
00523         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_router(__router).get());
00524     #endif
00525     }
00526 
00527     ::IceInternal::ProxyHandle<Message1> ice_locator(const ::Ice::LocatorPrx& __locator) const
00528     {
00529     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00530         typedef ::IceProxy::Ice::Object _Base;
00531         return dynamic_cast<Message1*>(_Base::ice_locator(__locator).get());
00532     #else
00533         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00534     #endif
00535     }
00536 
00537     ::IceInternal::ProxyHandle<Message1> ice_collocationOptimized(bool __co) const
00538     {
00539     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00540         typedef ::IceProxy::Ice::Object _Base;
00541         return dynamic_cast<Message1*>(_Base::ice_collocationOptimized(__co).get());
00542     #else
00543         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00544     #endif
00545     }
00546 
00547     ::IceInternal::ProxyHandle<Message1> ice_twoway() const
00548     {
00549     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00550         typedef ::IceProxy::Ice::Object _Base;
00551         return dynamic_cast<Message1*>(_Base::ice_twoway().get());
00552     #else
00553         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_twoway().get());
00554     #endif
00555     }
00556 
00557     ::IceInternal::ProxyHandle<Message1> ice_oneway() const
00558     {
00559     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00560         typedef ::IceProxy::Ice::Object _Base;
00561         return dynamic_cast<Message1*>(_Base::ice_oneway().get());
00562     #else
00563         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_oneway().get());
00564     #endif
00565     }
00566 
00567     ::IceInternal::ProxyHandle<Message1> ice_batchOneway() const
00568     {
00569     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00570         typedef ::IceProxy::Ice::Object _Base;
00571         return dynamic_cast<Message1*>(_Base::ice_batchOneway().get());
00572     #else
00573         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00574     #endif
00575     }
00576 
00577     ::IceInternal::ProxyHandle<Message1> ice_datagram() const
00578     {
00579     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00580         typedef ::IceProxy::Ice::Object _Base;
00581         return dynamic_cast<Message1*>(_Base::ice_datagram().get());
00582     #else
00583         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_datagram().get());
00584     #endif
00585     }
00586 
00587     ::IceInternal::ProxyHandle<Message1> ice_batchDatagram() const
00588     {
00589     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00590         typedef ::IceProxy::Ice::Object _Base;
00591         return dynamic_cast<Message1*>(_Base::ice_batchDatagram().get());
00592     #else
00593         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00594     #endif
00595     }
00596 
00597     ::IceInternal::ProxyHandle<Message1> ice_compress(bool __compress) const
00598     {
00599     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00600         typedef ::IceProxy::Ice::Object _Base;
00601         return dynamic_cast<Message1*>(_Base::ice_compress(__compress).get());
00602     #else
00603         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00604     #endif
00605     }
00606 
00607     ::IceInternal::ProxyHandle<Message1> ice_timeout(int __timeout) const
00608     {
00609     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00610         typedef ::IceProxy::Ice::Object _Base;
00611         return dynamic_cast<Message1*>(_Base::ice_timeout(__timeout).get());
00612     #else
00613         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00614     #endif
00615     }
00616 
00617     ::IceInternal::ProxyHandle<Message1> ice_connectionId(const std::string& __id) const
00618     {
00619     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00620         typedef ::IceProxy::Ice::Object _Base;
00621         return dynamic_cast<Message1*>(_Base::ice_connectionId(__id).get());
00622     #else
00623         return dynamic_cast<Message1*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00624     #endif
00625     }
00626 
00627     static const ::std::string& ice_staticId();
00628 
00629 private:
00630 
00631     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00632     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00633     virtual ::IceProxy::Ice::Object* __newInstance() const;
00634 };
00635 
00636 class Message2 : virtual public ::IceProxy::EventsNS::Event
00637 {
00638 public:
00639 
00640     ::IceInternal::ProxyHandle<Message2> ice_context(const ::Ice::Context& __context) const
00641     {
00642     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00643         typedef ::IceProxy::Ice::Object _Base;
00644         return dynamic_cast<Message2*>(_Base::ice_context(__context).get());
00645     #else
00646         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_context(__context).get());
00647     #endif
00648     }
00649 
00650     ::IceInternal::ProxyHandle<Message2> ice_adapterId(const std::string& __id) const
00651     {
00652     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00653         typedef ::IceProxy::Ice::Object _Base;
00654         return dynamic_cast<Message2*>(_Base::ice_adapterId(__id).get());
00655     #else
00656         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00657     #endif
00658     }
00659 
00660     ::IceInternal::ProxyHandle<Message2> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00661     {
00662     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00663         typedef ::IceProxy::Ice::Object _Base;
00664         return dynamic_cast<Message2*>(_Base::ice_endpoints(__endpoints).get());
00665     #else
00666         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00667     #endif
00668     }
00669 
00670     ::IceInternal::ProxyHandle<Message2> ice_locatorCacheTimeout(int __timeout) const
00671     {
00672     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00673         typedef ::IceProxy::Ice::Object _Base;
00674         return dynamic_cast<Message2*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00675     #else
00676         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00677     #endif
00678     }
00679 
00680     ::IceInternal::ProxyHandle<Message2> ice_connectionCached(bool __cached) const
00681     {
00682     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00683         typedef ::IceProxy::Ice::Object _Base;
00684         return dynamic_cast<Message2*>(_Base::ice_connectionCached(__cached).get());
00685     #else
00686         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00687     #endif
00688     }
00689 
00690     ::IceInternal::ProxyHandle<Message2> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00691     {
00692     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00693         typedef ::IceProxy::Ice::Object _Base;
00694         return dynamic_cast<Message2*>(_Base::ice_endpointSelection(__est).get());
00695     #else
00696         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00697     #endif
00698     }
00699 
00700     ::IceInternal::ProxyHandle<Message2> ice_secure(bool __secure) const
00701     {
00702     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00703         typedef ::IceProxy::Ice::Object _Base;
00704         return dynamic_cast<Message2*>(_Base::ice_secure(__secure).get());
00705     #else
00706         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00707     #endif
00708     }
00709 
00710     ::IceInternal::ProxyHandle<Message2> ice_preferSecure(bool __preferSecure) const
00711     {
00712     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00713         typedef ::IceProxy::Ice::Object _Base;
00714         return dynamic_cast<Message2*>(_Base::ice_preferSecure(__preferSecure).get());
00715     #else
00716         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00717     #endif
00718     }
00719 
00720     ::IceInternal::ProxyHandle<Message2> ice_router(const ::Ice::RouterPrx& __router) const
00721     {
00722     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00723         typedef ::IceProxy::Ice::Object _Base;
00724         return dynamic_cast<Message2*>(_Base::ice_router(__router).get());
00725     #else
00726         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_router(__router).get());
00727     #endif
00728     }
00729 
00730     ::IceInternal::ProxyHandle<Message2> ice_locator(const ::Ice::LocatorPrx& __locator) const
00731     {
00732     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00733         typedef ::IceProxy::Ice::Object _Base;
00734         return dynamic_cast<Message2*>(_Base::ice_locator(__locator).get());
00735     #else
00736         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00737     #endif
00738     }
00739 
00740     ::IceInternal::ProxyHandle<Message2> ice_collocationOptimized(bool __co) const
00741     {
00742     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00743         typedef ::IceProxy::Ice::Object _Base;
00744         return dynamic_cast<Message2*>(_Base::ice_collocationOptimized(__co).get());
00745     #else
00746         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00747     #endif
00748     }
00749 
00750     ::IceInternal::ProxyHandle<Message2> ice_twoway() const
00751     {
00752     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00753         typedef ::IceProxy::Ice::Object _Base;
00754         return dynamic_cast<Message2*>(_Base::ice_twoway().get());
00755     #else
00756         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_twoway().get());
00757     #endif
00758     }
00759 
00760     ::IceInternal::ProxyHandle<Message2> ice_oneway() const
00761     {
00762     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00763         typedef ::IceProxy::Ice::Object _Base;
00764         return dynamic_cast<Message2*>(_Base::ice_oneway().get());
00765     #else
00766         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_oneway().get());
00767     #endif
00768     }
00769 
00770     ::IceInternal::ProxyHandle<Message2> ice_batchOneway() const
00771     {
00772     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00773         typedef ::IceProxy::Ice::Object _Base;
00774         return dynamic_cast<Message2*>(_Base::ice_batchOneway().get());
00775     #else
00776         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00777     #endif
00778     }
00779 
00780     ::IceInternal::ProxyHandle<Message2> ice_datagram() const
00781     {
00782     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00783         typedef ::IceProxy::Ice::Object _Base;
00784         return dynamic_cast<Message2*>(_Base::ice_datagram().get());
00785     #else
00786         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_datagram().get());
00787     #endif
00788     }
00789 
00790     ::IceInternal::ProxyHandle<Message2> ice_batchDatagram() const
00791     {
00792     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00793         typedef ::IceProxy::Ice::Object _Base;
00794         return dynamic_cast<Message2*>(_Base::ice_batchDatagram().get());
00795     #else
00796         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00797     #endif
00798     }
00799 
00800     ::IceInternal::ProxyHandle<Message2> ice_compress(bool __compress) const
00801     {
00802     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00803         typedef ::IceProxy::Ice::Object _Base;
00804         return dynamic_cast<Message2*>(_Base::ice_compress(__compress).get());
00805     #else
00806         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00807     #endif
00808     }
00809 
00810     ::IceInternal::ProxyHandle<Message2> ice_timeout(int __timeout) const
00811     {
00812     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00813         typedef ::IceProxy::Ice::Object _Base;
00814         return dynamic_cast<Message2*>(_Base::ice_timeout(__timeout).get());
00815     #else
00816         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00817     #endif
00818     }
00819 
00820     ::IceInternal::ProxyHandle<Message2> ice_connectionId(const std::string& __id) const
00821     {
00822     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00823         typedef ::IceProxy::Ice::Object _Base;
00824         return dynamic_cast<Message2*>(_Base::ice_connectionId(__id).get());
00825     #else
00826         return dynamic_cast<Message2*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00827     #endif
00828     }
00829 
00830     static const ::std::string& ice_staticId();
00831 
00832 private:
00833 
00834     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00835     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00836     virtual ::IceProxy::Ice::Object* __newInstance() const;
00837 };
00838 
00839 class Events : virtual public ::IceProxy::Ice::Object
00840 {
00841 public:
00842 
00843     void evolve(const ::EventsNS::EventPtr& e)
00844     {
00845         evolve(e, 0);
00846     }
00847     void evolve(const ::EventsNS::EventPtr& e, const ::Ice::Context& __ctx)
00848     {
00849         evolve(e, &__ctx);
00850     }
00851 
00852 private:
00853 
00854     void evolve(const ::EventsNS::EventPtr&, const ::Ice::Context*);
00855 
00856 public:
00857     bool evolve_async(const ::EventsNS::AMI_Events_evolvePtr&, const ::EventsNS::EventPtr&);
00858     bool evolve_async(const ::EventsNS::AMI_Events_evolvePtr&, const ::EventsNS::EventPtr&, const ::Ice::Context&);
00859 
00860     ::IceInternal::ProxyHandle<Events> ice_context(const ::Ice::Context& __context) const
00861     {
00862     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00863         typedef ::IceProxy::Ice::Object _Base;
00864         return dynamic_cast<Events*>(_Base::ice_context(__context).get());
00865     #else
00866         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_context(__context).get());
00867     #endif
00868     }
00869 
00870     ::IceInternal::ProxyHandle<Events> ice_adapterId(const std::string& __id) const
00871     {
00872     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00873         typedef ::IceProxy::Ice::Object _Base;
00874         return dynamic_cast<Events*>(_Base::ice_adapterId(__id).get());
00875     #else
00876         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00877     #endif
00878     }
00879 
00880     ::IceInternal::ProxyHandle<Events> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00881     {
00882     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00883         typedef ::IceProxy::Ice::Object _Base;
00884         return dynamic_cast<Events*>(_Base::ice_endpoints(__endpoints).get());
00885     #else
00886         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00887     #endif
00888     }
00889 
00890     ::IceInternal::ProxyHandle<Events> ice_locatorCacheTimeout(int __timeout) const
00891     {
00892     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00893         typedef ::IceProxy::Ice::Object _Base;
00894         return dynamic_cast<Events*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00895     #else
00896         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00897     #endif
00898     }
00899 
00900     ::IceInternal::ProxyHandle<Events> ice_connectionCached(bool __cached) const
00901     {
00902     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00903         typedef ::IceProxy::Ice::Object _Base;
00904         return dynamic_cast<Events*>(_Base::ice_connectionCached(__cached).get());
00905     #else
00906         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00907     #endif
00908     }
00909 
00910     ::IceInternal::ProxyHandle<Events> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00911     {
00912     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00913         typedef ::IceProxy::Ice::Object _Base;
00914         return dynamic_cast<Events*>(_Base::ice_endpointSelection(__est).get());
00915     #else
00916         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00917     #endif
00918     }
00919 
00920     ::IceInternal::ProxyHandle<Events> ice_secure(bool __secure) const
00921     {
00922     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00923         typedef ::IceProxy::Ice::Object _Base;
00924         return dynamic_cast<Events*>(_Base::ice_secure(__secure).get());
00925     #else
00926         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00927     #endif
00928     }
00929 
00930     ::IceInternal::ProxyHandle<Events> ice_preferSecure(bool __preferSecure) const
00931     {
00932     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00933         typedef ::IceProxy::Ice::Object _Base;
00934         return dynamic_cast<Events*>(_Base::ice_preferSecure(__preferSecure).get());
00935     #else
00936         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00937     #endif
00938     }
00939 
00940     ::IceInternal::ProxyHandle<Events> ice_router(const ::Ice::RouterPrx& __router) const
00941     {
00942     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00943         typedef ::IceProxy::Ice::Object _Base;
00944         return dynamic_cast<Events*>(_Base::ice_router(__router).get());
00945     #else
00946         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_router(__router).get());
00947     #endif
00948     }
00949 
00950     ::IceInternal::ProxyHandle<Events> ice_locator(const ::Ice::LocatorPrx& __locator) const
00951     {
00952     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00953         typedef ::IceProxy::Ice::Object _Base;
00954         return dynamic_cast<Events*>(_Base::ice_locator(__locator).get());
00955     #else
00956         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00957     #endif
00958     }
00959 
00960     ::IceInternal::ProxyHandle<Events> ice_collocationOptimized(bool __co) const
00961     {
00962     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00963         typedef ::IceProxy::Ice::Object _Base;
00964         return dynamic_cast<Events*>(_Base::ice_collocationOptimized(__co).get());
00965     #else
00966         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00967     #endif
00968     }
00969 
00970     ::IceInternal::ProxyHandle<Events> ice_twoway() const
00971     {
00972     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00973         typedef ::IceProxy::Ice::Object _Base;
00974         return dynamic_cast<Events*>(_Base::ice_twoway().get());
00975     #else
00976         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_twoway().get());
00977     #endif
00978     }
00979 
00980     ::IceInternal::ProxyHandle<Events> ice_oneway() const
00981     {
00982     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00983         typedef ::IceProxy::Ice::Object _Base;
00984         return dynamic_cast<Events*>(_Base::ice_oneway().get());
00985     #else
00986         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_oneway().get());
00987     #endif
00988     }
00989 
00990     ::IceInternal::ProxyHandle<Events> ice_batchOneway() const
00991     {
00992     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00993         typedef ::IceProxy::Ice::Object _Base;
00994         return dynamic_cast<Events*>(_Base::ice_batchOneway().get());
00995     #else
00996         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00997     #endif
00998     }
00999 
01000     ::IceInternal::ProxyHandle<Events> ice_datagram() const
01001     {
01002     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01003         typedef ::IceProxy::Ice::Object _Base;
01004         return dynamic_cast<Events*>(_Base::ice_datagram().get());
01005     #else
01006         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_datagram().get());
01007     #endif
01008     }
01009 
01010     ::IceInternal::ProxyHandle<Events> ice_batchDatagram() const
01011     {
01012     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01013         typedef ::IceProxy::Ice::Object _Base;
01014         return dynamic_cast<Events*>(_Base::ice_batchDatagram().get());
01015     #else
01016         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01017     #endif
01018     }
01019 
01020     ::IceInternal::ProxyHandle<Events> ice_compress(bool __compress) const
01021     {
01022     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01023         typedef ::IceProxy::Ice::Object _Base;
01024         return dynamic_cast<Events*>(_Base::ice_compress(__compress).get());
01025     #else
01026         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01027     #endif
01028     }
01029 
01030     ::IceInternal::ProxyHandle<Events> ice_timeout(int __timeout) const
01031     {
01032     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01033         typedef ::IceProxy::Ice::Object _Base;
01034         return dynamic_cast<Events*>(_Base::ice_timeout(__timeout).get());
01035     #else
01036         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01037     #endif
01038     }
01039 
01040     ::IceInternal::ProxyHandle<Events> ice_connectionId(const std::string& __id) const
01041     {
01042     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01043         typedef ::IceProxy::Ice::Object _Base;
01044         return dynamic_cast<Events*>(_Base::ice_connectionId(__id).get());
01045     #else
01046         return dynamic_cast<Events*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01047     #endif
01048     }
01049 
01050     static const ::std::string& ice_staticId();
01051 
01052 private:
01053 
01054     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01055     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01056     virtual ::IceProxy::Ice::Object* __newInstance() const;
01057 };
01058 
01059 }
01060 
01061 namespace TestPub
01062 {
01063 
01064 class Publisher1 : virtual public ::IceProxy::EventsNS::Events
01065 {
01066 public:
01067 
01068     ::IceInternal::ProxyHandle<Publisher1> ice_context(const ::Ice::Context& __context) const
01069     {
01070     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01071         typedef ::IceProxy::Ice::Object _Base;
01072         return dynamic_cast<Publisher1*>(_Base::ice_context(__context).get());
01073     #else
01074         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_context(__context).get());
01075     #endif
01076     }
01077 
01078     ::IceInternal::ProxyHandle<Publisher1> ice_adapterId(const std::string& __id) const
01079     {
01080     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01081         typedef ::IceProxy::Ice::Object _Base;
01082         return dynamic_cast<Publisher1*>(_Base::ice_adapterId(__id).get());
01083     #else
01084         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01085     #endif
01086     }
01087 
01088     ::IceInternal::ProxyHandle<Publisher1> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01089     {
01090     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01091         typedef ::IceProxy::Ice::Object _Base;
01092         return dynamic_cast<Publisher1*>(_Base::ice_endpoints(__endpoints).get());
01093     #else
01094         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01095     #endif
01096     }
01097 
01098     ::IceInternal::ProxyHandle<Publisher1> ice_locatorCacheTimeout(int __timeout) const
01099     {
01100     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01101         typedef ::IceProxy::Ice::Object _Base;
01102         return dynamic_cast<Publisher1*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01103     #else
01104         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01105     #endif
01106     }
01107 
01108     ::IceInternal::ProxyHandle<Publisher1> ice_connectionCached(bool __cached) const
01109     {
01110     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01111         typedef ::IceProxy::Ice::Object _Base;
01112         return dynamic_cast<Publisher1*>(_Base::ice_connectionCached(__cached).get());
01113     #else
01114         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01115     #endif
01116     }
01117 
01118     ::IceInternal::ProxyHandle<Publisher1> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01119     {
01120     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01121         typedef ::IceProxy::Ice::Object _Base;
01122         return dynamic_cast<Publisher1*>(_Base::ice_endpointSelection(__est).get());
01123     #else
01124         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01125     #endif
01126     }
01127 
01128     ::IceInternal::ProxyHandle<Publisher1> ice_secure(bool __secure) const
01129     {
01130     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01131         typedef ::IceProxy::Ice::Object _Base;
01132         return dynamic_cast<Publisher1*>(_Base::ice_secure(__secure).get());
01133     #else
01134         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01135     #endif
01136     }
01137 
01138     ::IceInternal::ProxyHandle<Publisher1> ice_preferSecure(bool __preferSecure) const
01139     {
01140     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01141         typedef ::IceProxy::Ice::Object _Base;
01142         return dynamic_cast<Publisher1*>(_Base::ice_preferSecure(__preferSecure).get());
01143     #else
01144         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01145     #endif
01146     }
01147 
01148     ::IceInternal::ProxyHandle<Publisher1> ice_router(const ::Ice::RouterPrx& __router) const
01149     {
01150     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01151         typedef ::IceProxy::Ice::Object _Base;
01152         return dynamic_cast<Publisher1*>(_Base::ice_router(__router).get());
01153     #else
01154         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_router(__router).get());
01155     #endif
01156     }
01157 
01158     ::IceInternal::ProxyHandle<Publisher1> ice_locator(const ::Ice::LocatorPrx& __locator) const
01159     {
01160     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01161         typedef ::IceProxy::Ice::Object _Base;
01162         return dynamic_cast<Publisher1*>(_Base::ice_locator(__locator).get());
01163     #else
01164         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01165     #endif
01166     }
01167 
01168     ::IceInternal::ProxyHandle<Publisher1> ice_collocationOptimized(bool __co) const
01169     {
01170     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01171         typedef ::IceProxy::Ice::Object _Base;
01172         return dynamic_cast<Publisher1*>(_Base::ice_collocationOptimized(__co).get());
01173     #else
01174         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01175     #endif
01176     }
01177 
01178     ::IceInternal::ProxyHandle<Publisher1> ice_twoway() const
01179     {
01180     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01181         typedef ::IceProxy::Ice::Object _Base;
01182         return dynamic_cast<Publisher1*>(_Base::ice_twoway().get());
01183     #else
01184         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_twoway().get());
01185     #endif
01186     }
01187 
01188     ::IceInternal::ProxyHandle<Publisher1> ice_oneway() const
01189     {
01190     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01191         typedef ::IceProxy::Ice::Object _Base;
01192         return dynamic_cast<Publisher1*>(_Base::ice_oneway().get());
01193     #else
01194         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_oneway().get());
01195     #endif
01196     }
01197 
01198     ::IceInternal::ProxyHandle<Publisher1> ice_batchOneway() const
01199     {
01200     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01201         typedef ::IceProxy::Ice::Object _Base;
01202         return dynamic_cast<Publisher1*>(_Base::ice_batchOneway().get());
01203     #else
01204         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01205     #endif
01206     }
01207 
01208     ::IceInternal::ProxyHandle<Publisher1> ice_datagram() const
01209     {
01210     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01211         typedef ::IceProxy::Ice::Object _Base;
01212         return dynamic_cast<Publisher1*>(_Base::ice_datagram().get());
01213     #else
01214         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_datagram().get());
01215     #endif
01216     }
01217 
01218     ::IceInternal::ProxyHandle<Publisher1> ice_batchDatagram() const
01219     {
01220     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01221         typedef ::IceProxy::Ice::Object _Base;
01222         return dynamic_cast<Publisher1*>(_Base::ice_batchDatagram().get());
01223     #else
01224         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01225     #endif
01226     }
01227 
01228     ::IceInternal::ProxyHandle<Publisher1> ice_compress(bool __compress) const
01229     {
01230     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01231         typedef ::IceProxy::Ice::Object _Base;
01232         return dynamic_cast<Publisher1*>(_Base::ice_compress(__compress).get());
01233     #else
01234         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01235     #endif
01236     }
01237 
01238     ::IceInternal::ProxyHandle<Publisher1> ice_timeout(int __timeout) const
01239     {
01240     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01241         typedef ::IceProxy::Ice::Object _Base;
01242         return dynamic_cast<Publisher1*>(_Base::ice_timeout(__timeout).get());
01243     #else
01244         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01245     #endif
01246     }
01247 
01248     ::IceInternal::ProxyHandle<Publisher1> ice_connectionId(const std::string& __id) const
01249     {
01250     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01251         typedef ::IceProxy::Ice::Object _Base;
01252         return dynamic_cast<Publisher1*>(_Base::ice_connectionId(__id).get());
01253     #else
01254         return dynamic_cast<Publisher1*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01255     #endif
01256     }
01257 
01258     static const ::std::string& ice_staticId();
01259 
01260 private:
01261 
01262     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01263     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01264     virtual ::IceProxy::Ice::Object* __newInstance() const;
01265 };
01266 
01267 class Publisher2 : virtual public ::IceProxy::EventsNS::Events
01268 {
01269 public:
01270 
01271     ::IceInternal::ProxyHandle<Publisher2> ice_context(const ::Ice::Context& __context) const
01272     {
01273     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01274         typedef ::IceProxy::Ice::Object _Base;
01275         return dynamic_cast<Publisher2*>(_Base::ice_context(__context).get());
01276     #else
01277         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_context(__context).get());
01278     #endif
01279     }
01280 
01281     ::IceInternal::ProxyHandle<Publisher2> ice_adapterId(const std::string& __id) const
01282     {
01283     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01284         typedef ::IceProxy::Ice::Object _Base;
01285         return dynamic_cast<Publisher2*>(_Base::ice_adapterId(__id).get());
01286     #else
01287         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01288     #endif
01289     }
01290 
01291     ::IceInternal::ProxyHandle<Publisher2> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01292     {
01293     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01294         typedef ::IceProxy::Ice::Object _Base;
01295         return dynamic_cast<Publisher2*>(_Base::ice_endpoints(__endpoints).get());
01296     #else
01297         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01298     #endif
01299     }
01300 
01301     ::IceInternal::ProxyHandle<Publisher2> ice_locatorCacheTimeout(int __timeout) const
01302     {
01303     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01304         typedef ::IceProxy::Ice::Object _Base;
01305         return dynamic_cast<Publisher2*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01306     #else
01307         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01308     #endif
01309     }
01310 
01311     ::IceInternal::ProxyHandle<Publisher2> ice_connectionCached(bool __cached) const
01312     {
01313     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01314         typedef ::IceProxy::Ice::Object _Base;
01315         return dynamic_cast<Publisher2*>(_Base::ice_connectionCached(__cached).get());
01316     #else
01317         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01318     #endif
01319     }
01320 
01321     ::IceInternal::ProxyHandle<Publisher2> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01322     {
01323     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01324         typedef ::IceProxy::Ice::Object _Base;
01325         return dynamic_cast<Publisher2*>(_Base::ice_endpointSelection(__est).get());
01326     #else
01327         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01328     #endif
01329     }
01330 
01331     ::IceInternal::ProxyHandle<Publisher2> ice_secure(bool __secure) const
01332     {
01333     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01334         typedef ::IceProxy::Ice::Object _Base;
01335         return dynamic_cast<Publisher2*>(_Base::ice_secure(__secure).get());
01336     #else
01337         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01338     #endif
01339     }
01340 
01341     ::IceInternal::ProxyHandle<Publisher2> ice_preferSecure(bool __preferSecure) const
01342     {
01343     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01344         typedef ::IceProxy::Ice::Object _Base;
01345         return dynamic_cast<Publisher2*>(_Base::ice_preferSecure(__preferSecure).get());
01346     #else
01347         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01348     #endif
01349     }
01350 
01351     ::IceInternal::ProxyHandle<Publisher2> ice_router(const ::Ice::RouterPrx& __router) const
01352     {
01353     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01354         typedef ::IceProxy::Ice::Object _Base;
01355         return dynamic_cast<Publisher2*>(_Base::ice_router(__router).get());
01356     #else
01357         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_router(__router).get());
01358     #endif
01359     }
01360 
01361     ::IceInternal::ProxyHandle<Publisher2> ice_locator(const ::Ice::LocatorPrx& __locator) const
01362     {
01363     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01364         typedef ::IceProxy::Ice::Object _Base;
01365         return dynamic_cast<Publisher2*>(_Base::ice_locator(__locator).get());
01366     #else
01367         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01368     #endif
01369     }
01370 
01371     ::IceInternal::ProxyHandle<Publisher2> ice_collocationOptimized(bool __co) const
01372     {
01373     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01374         typedef ::IceProxy::Ice::Object _Base;
01375         return dynamic_cast<Publisher2*>(_Base::ice_collocationOptimized(__co).get());
01376     #else
01377         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01378     #endif
01379     }
01380 
01381     ::IceInternal::ProxyHandle<Publisher2> ice_twoway() const
01382     {
01383     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01384         typedef ::IceProxy::Ice::Object _Base;
01385         return dynamic_cast<Publisher2*>(_Base::ice_twoway().get());
01386     #else
01387         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_twoway().get());
01388     #endif
01389     }
01390 
01391     ::IceInternal::ProxyHandle<Publisher2> ice_oneway() const
01392     {
01393     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01394         typedef ::IceProxy::Ice::Object _Base;
01395         return dynamic_cast<Publisher2*>(_Base::ice_oneway().get());
01396     #else
01397         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_oneway().get());
01398     #endif
01399     }
01400 
01401     ::IceInternal::ProxyHandle<Publisher2> ice_batchOneway() const
01402     {
01403     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01404         typedef ::IceProxy::Ice::Object _Base;
01405         return dynamic_cast<Publisher2*>(_Base::ice_batchOneway().get());
01406     #else
01407         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01408     #endif
01409     }
01410 
01411     ::IceInternal::ProxyHandle<Publisher2> ice_datagram() const
01412     {
01413     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01414         typedef ::IceProxy::Ice::Object _Base;
01415         return dynamic_cast<Publisher2*>(_Base::ice_datagram().get());
01416     #else
01417         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_datagram().get());
01418     #endif
01419     }
01420 
01421     ::IceInternal::ProxyHandle<Publisher2> ice_batchDatagram() const
01422     {
01423     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01424         typedef ::IceProxy::Ice::Object _Base;
01425         return dynamic_cast<Publisher2*>(_Base::ice_batchDatagram().get());
01426     #else
01427         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01428     #endif
01429     }
01430 
01431     ::IceInternal::ProxyHandle<Publisher2> ice_compress(bool __compress) const
01432     {
01433     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01434         typedef ::IceProxy::Ice::Object _Base;
01435         return dynamic_cast<Publisher2*>(_Base::ice_compress(__compress).get());
01436     #else
01437         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01438     #endif
01439     }
01440 
01441     ::IceInternal::ProxyHandle<Publisher2> ice_timeout(int __timeout) const
01442     {
01443     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01444         typedef ::IceProxy::Ice::Object _Base;
01445         return dynamic_cast<Publisher2*>(_Base::ice_timeout(__timeout).get());
01446     #else
01447         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01448     #endif
01449     }
01450 
01451     ::IceInternal::ProxyHandle<Publisher2> ice_connectionId(const std::string& __id) const
01452     {
01453     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01454         typedef ::IceProxy::Ice::Object _Base;
01455         return dynamic_cast<Publisher2*>(_Base::ice_connectionId(__id).get());
01456     #else
01457         return dynamic_cast<Publisher2*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01458     #endif
01459     }
01460 
01461     static const ::std::string& ice_staticId();
01462 
01463 private:
01464 
01465     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01466     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01467     virtual ::IceProxy::Ice::Object* __newInstance() const;
01468 };
01469 
01470 class Subscriber1 : virtual public ::IceProxy::EventsNS::Events
01471 {
01472 public:
01473 
01474     ::IceInternal::ProxyHandle<Subscriber1> ice_context(const ::Ice::Context& __context) const
01475     {
01476     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01477         typedef ::IceProxy::Ice::Object _Base;
01478         return dynamic_cast<Subscriber1*>(_Base::ice_context(__context).get());
01479     #else
01480         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_context(__context).get());
01481     #endif
01482     }
01483 
01484     ::IceInternal::ProxyHandle<Subscriber1> ice_adapterId(const std::string& __id) const
01485     {
01486     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01487         typedef ::IceProxy::Ice::Object _Base;
01488         return dynamic_cast<Subscriber1*>(_Base::ice_adapterId(__id).get());
01489     #else
01490         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01491     #endif
01492     }
01493 
01494     ::IceInternal::ProxyHandle<Subscriber1> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01495     {
01496     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01497         typedef ::IceProxy::Ice::Object _Base;
01498         return dynamic_cast<Subscriber1*>(_Base::ice_endpoints(__endpoints).get());
01499     #else
01500         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01501     #endif
01502     }
01503 
01504     ::IceInternal::ProxyHandle<Subscriber1> ice_locatorCacheTimeout(int __timeout) const
01505     {
01506     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01507         typedef ::IceProxy::Ice::Object _Base;
01508         return dynamic_cast<Subscriber1*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01509     #else
01510         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01511     #endif
01512     }
01513 
01514     ::IceInternal::ProxyHandle<Subscriber1> ice_connectionCached(bool __cached) const
01515     {
01516     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01517         typedef ::IceProxy::Ice::Object _Base;
01518         return dynamic_cast<Subscriber1*>(_Base::ice_connectionCached(__cached).get());
01519     #else
01520         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01521     #endif
01522     }
01523 
01524     ::IceInternal::ProxyHandle<Subscriber1> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01525     {
01526     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01527         typedef ::IceProxy::Ice::Object _Base;
01528         return dynamic_cast<Subscriber1*>(_Base::ice_endpointSelection(__est).get());
01529     #else
01530         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01531     #endif
01532     }
01533 
01534     ::IceInternal::ProxyHandle<Subscriber1> ice_secure(bool __secure) const
01535     {
01536     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01537         typedef ::IceProxy::Ice::Object _Base;
01538         return dynamic_cast<Subscriber1*>(_Base::ice_secure(__secure).get());
01539     #else
01540         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01541     #endif
01542     }
01543 
01544     ::IceInternal::ProxyHandle<Subscriber1> ice_preferSecure(bool __preferSecure) const
01545     {
01546     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01547         typedef ::IceProxy::Ice::Object _Base;
01548         return dynamic_cast<Subscriber1*>(_Base::ice_preferSecure(__preferSecure).get());
01549     #else
01550         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01551     #endif
01552     }
01553 
01554     ::IceInternal::ProxyHandle<Subscriber1> ice_router(const ::Ice::RouterPrx& __router) const
01555     {
01556     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01557         typedef ::IceProxy::Ice::Object _Base;
01558         return dynamic_cast<Subscriber1*>(_Base::ice_router(__router).get());
01559     #else
01560         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_router(__router).get());
01561     #endif
01562     }
01563 
01564     ::IceInternal::ProxyHandle<Subscriber1> ice_locator(const ::Ice::LocatorPrx& __locator) const
01565     {
01566     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01567         typedef ::IceProxy::Ice::Object _Base;
01568         return dynamic_cast<Subscriber1*>(_Base::ice_locator(__locator).get());
01569     #else
01570         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01571     #endif
01572     }
01573 
01574     ::IceInternal::ProxyHandle<Subscriber1> ice_collocationOptimized(bool __co) const
01575     {
01576     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01577         typedef ::IceProxy::Ice::Object _Base;
01578         return dynamic_cast<Subscriber1*>(_Base::ice_collocationOptimized(__co).get());
01579     #else
01580         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01581     #endif
01582     }
01583 
01584     ::IceInternal::ProxyHandle<Subscriber1> ice_twoway() const
01585     {
01586     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01587         typedef ::IceProxy::Ice::Object _Base;
01588         return dynamic_cast<Subscriber1*>(_Base::ice_twoway().get());
01589     #else
01590         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_twoway().get());
01591     #endif
01592     }
01593 
01594     ::IceInternal::ProxyHandle<Subscriber1> ice_oneway() const
01595     {
01596     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01597         typedef ::IceProxy::Ice::Object _Base;
01598         return dynamic_cast<Subscriber1*>(_Base::ice_oneway().get());
01599     #else
01600         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_oneway().get());
01601     #endif
01602     }
01603 
01604     ::IceInternal::ProxyHandle<Subscriber1> ice_batchOneway() const
01605     {
01606     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01607         typedef ::IceProxy::Ice::Object _Base;
01608         return dynamic_cast<Subscriber1*>(_Base::ice_batchOneway().get());
01609     #else
01610         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01611     #endif
01612     }
01613 
01614     ::IceInternal::ProxyHandle<Subscriber1> ice_datagram() const
01615     {
01616     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01617         typedef ::IceProxy::Ice::Object _Base;
01618         return dynamic_cast<Subscriber1*>(_Base::ice_datagram().get());
01619     #else
01620         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_datagram().get());
01621     #endif
01622     }
01623 
01624     ::IceInternal::ProxyHandle<Subscriber1> ice_batchDatagram() const
01625     {
01626     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01627         typedef ::IceProxy::Ice::Object _Base;
01628         return dynamic_cast<Subscriber1*>(_Base::ice_batchDatagram().get());
01629     #else
01630         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01631     #endif
01632     }
01633 
01634     ::IceInternal::ProxyHandle<Subscriber1> ice_compress(bool __compress) const
01635     {
01636     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01637         typedef ::IceProxy::Ice::Object _Base;
01638         return dynamic_cast<Subscriber1*>(_Base::ice_compress(__compress).get());
01639     #else
01640         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01641     #endif
01642     }
01643 
01644     ::IceInternal::ProxyHandle<Subscriber1> ice_timeout(int __timeout) const
01645     {
01646     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01647         typedef ::IceProxy::Ice::Object _Base;
01648         return dynamic_cast<Subscriber1*>(_Base::ice_timeout(__timeout).get());
01649     #else
01650         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01651     #endif
01652     }
01653 
01654     ::IceInternal::ProxyHandle<Subscriber1> ice_connectionId(const std::string& __id) const
01655     {
01656     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01657         typedef ::IceProxy::Ice::Object _Base;
01658         return dynamic_cast<Subscriber1*>(_Base::ice_connectionId(__id).get());
01659     #else
01660         return dynamic_cast<Subscriber1*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01661     #endif
01662     }
01663 
01664     static const ::std::string& ice_staticId();
01665 
01666 private:
01667 
01668     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01669     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01670     virtual ::IceProxy::Ice::Object* __newInstance() const;
01671 };
01672 
01673 class Subscriber2 : virtual public ::IceProxy::EventsNS::Events
01674 {
01675 public:
01676 
01677     ::IceInternal::ProxyHandle<Subscriber2> ice_context(const ::Ice::Context& __context) const
01678     {
01679     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01680         typedef ::IceProxy::Ice::Object _Base;
01681         return dynamic_cast<Subscriber2*>(_Base::ice_context(__context).get());
01682     #else
01683         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_context(__context).get());
01684     #endif
01685     }
01686 
01687     ::IceInternal::ProxyHandle<Subscriber2> ice_adapterId(const std::string& __id) const
01688     {
01689     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01690         typedef ::IceProxy::Ice::Object _Base;
01691         return dynamic_cast<Subscriber2*>(_Base::ice_adapterId(__id).get());
01692     #else
01693         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
01694     #endif
01695     }
01696 
01697     ::IceInternal::ProxyHandle<Subscriber2> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
01698     {
01699     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01700         typedef ::IceProxy::Ice::Object _Base;
01701         return dynamic_cast<Subscriber2*>(_Base::ice_endpoints(__endpoints).get());
01702     #else
01703         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
01704     #endif
01705     }
01706 
01707     ::IceInternal::ProxyHandle<Subscriber2> ice_locatorCacheTimeout(int __timeout) const
01708     {
01709     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01710         typedef ::IceProxy::Ice::Object _Base;
01711         return dynamic_cast<Subscriber2*>(_Base::ice_locatorCacheTimeout(__timeout).get());
01712     #else
01713         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
01714     #endif
01715     }
01716 
01717     ::IceInternal::ProxyHandle<Subscriber2> ice_connectionCached(bool __cached) const
01718     {
01719     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01720         typedef ::IceProxy::Ice::Object _Base;
01721         return dynamic_cast<Subscriber2*>(_Base::ice_connectionCached(__cached).get());
01722     #else
01723         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
01724     #endif
01725     }
01726 
01727     ::IceInternal::ProxyHandle<Subscriber2> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
01728     {
01729     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01730         typedef ::IceProxy::Ice::Object _Base;
01731         return dynamic_cast<Subscriber2*>(_Base::ice_endpointSelection(__est).get());
01732     #else
01733         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
01734     #endif
01735     }
01736 
01737     ::IceInternal::ProxyHandle<Subscriber2> ice_secure(bool __secure) const
01738     {
01739     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01740         typedef ::IceProxy::Ice::Object _Base;
01741         return dynamic_cast<Subscriber2*>(_Base::ice_secure(__secure).get());
01742     #else
01743         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
01744     #endif
01745     }
01746 
01747     ::IceInternal::ProxyHandle<Subscriber2> ice_preferSecure(bool __preferSecure) const
01748     {
01749     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01750         typedef ::IceProxy::Ice::Object _Base;
01751         return dynamic_cast<Subscriber2*>(_Base::ice_preferSecure(__preferSecure).get());
01752     #else
01753         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
01754     #endif
01755     }
01756 
01757     ::IceInternal::ProxyHandle<Subscriber2> ice_router(const ::Ice::RouterPrx& __router) const
01758     {
01759     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01760         typedef ::IceProxy::Ice::Object _Base;
01761         return dynamic_cast<Subscriber2*>(_Base::ice_router(__router).get());
01762     #else
01763         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_router(__router).get());
01764     #endif
01765     }
01766 
01767     ::IceInternal::ProxyHandle<Subscriber2> ice_locator(const ::Ice::LocatorPrx& __locator) const
01768     {
01769     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01770         typedef ::IceProxy::Ice::Object _Base;
01771         return dynamic_cast<Subscriber2*>(_Base::ice_locator(__locator).get());
01772     #else
01773         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
01774     #endif
01775     }
01776 
01777     ::IceInternal::ProxyHandle<Subscriber2> ice_collocationOptimized(bool __co) const
01778     {
01779     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01780         typedef ::IceProxy::Ice::Object _Base;
01781         return dynamic_cast<Subscriber2*>(_Base::ice_collocationOptimized(__co).get());
01782     #else
01783         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
01784     #endif
01785     }
01786 
01787     ::IceInternal::ProxyHandle<Subscriber2> ice_twoway() const
01788     {
01789     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01790         typedef ::IceProxy::Ice::Object _Base;
01791         return dynamic_cast<Subscriber2*>(_Base::ice_twoway().get());
01792     #else
01793         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_twoway().get());
01794     #endif
01795     }
01796 
01797     ::IceInternal::ProxyHandle<Subscriber2> ice_oneway() const
01798     {
01799     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01800         typedef ::IceProxy::Ice::Object _Base;
01801         return dynamic_cast<Subscriber2*>(_Base::ice_oneway().get());
01802     #else
01803         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_oneway().get());
01804     #endif
01805     }
01806 
01807     ::IceInternal::ProxyHandle<Subscriber2> ice_batchOneway() const
01808     {
01809     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01810         typedef ::IceProxy::Ice::Object _Base;
01811         return dynamic_cast<Subscriber2*>(_Base::ice_batchOneway().get());
01812     #else
01813         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_batchOneway().get());
01814     #endif
01815     }
01816 
01817     ::IceInternal::ProxyHandle<Subscriber2> ice_datagram() const
01818     {
01819     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01820         typedef ::IceProxy::Ice::Object _Base;
01821         return dynamic_cast<Subscriber2*>(_Base::ice_datagram().get());
01822     #else
01823         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_datagram().get());
01824     #endif
01825     }
01826 
01827     ::IceInternal::ProxyHandle<Subscriber2> ice_batchDatagram() const
01828     {
01829     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01830         typedef ::IceProxy::Ice::Object _Base;
01831         return dynamic_cast<Subscriber2*>(_Base::ice_batchDatagram().get());
01832     #else
01833         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
01834     #endif
01835     }
01836 
01837     ::IceInternal::ProxyHandle<Subscriber2> ice_compress(bool __compress) const
01838     {
01839     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01840         typedef ::IceProxy::Ice::Object _Base;
01841         return dynamic_cast<Subscriber2*>(_Base::ice_compress(__compress).get());
01842     #else
01843         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
01844     #endif
01845     }
01846 
01847     ::IceInternal::ProxyHandle<Subscriber2> ice_timeout(int __timeout) const
01848     {
01849     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01850         typedef ::IceProxy::Ice::Object _Base;
01851         return dynamic_cast<Subscriber2*>(_Base::ice_timeout(__timeout).get());
01852     #else
01853         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
01854     #endif
01855     }
01856 
01857     ::IceInternal::ProxyHandle<Subscriber2> ice_connectionId(const std::string& __id) const
01858     {
01859     #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01860         typedef ::IceProxy::Ice::Object _Base;
01861         return dynamic_cast<Subscriber2*>(_Base::ice_connectionId(__id).get());
01862     #else
01863         return dynamic_cast<Subscriber2*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
01864     #endif
01865     }
01866 
01867     static const ::std::string& ice_staticId();
01868 
01869 private:
01870 
01871     virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
01872     virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
01873     virtual ::IceProxy::Ice::Object* __newInstance() const;
01874 };
01875 
01876 }
01877 
01878 }
01879 
01880 namespace IceDelegate
01881 {
01882 
01883 namespace EventsNS
01884 {
01885 
01886 class Event : virtual public ::IceDelegate::Ice::Object
01887 {
01888 public:
01889 };
01890 
01891 class Message1 : virtual public ::IceDelegate::EventsNS::Event
01892 {
01893 public:
01894 };
01895 
01896 class Message2 : virtual public ::IceDelegate::EventsNS::Event
01897 {
01898 public:
01899 };
01900 
01901 class Events : virtual public ::IceDelegate::Ice::Object
01902 {
01903 public:
01904 
01905     virtual void evolve(const ::EventsNS::EventPtr&, const ::Ice::Context*) = 0;
01906 };
01907 
01908 }
01909 
01910 namespace TestPub
01911 {
01912 
01913 class Publisher1 : virtual public ::IceDelegate::EventsNS::Events
01914 {
01915 public:
01916 };
01917 
01918 class Publisher2 : virtual public ::IceDelegate::EventsNS::Events
01919 {
01920 public:
01921 };
01922 
01923 class Subscriber1 : virtual public ::IceDelegate::EventsNS::Events
01924 {
01925 public:
01926 };
01927 
01928 class Subscriber2 : virtual public ::IceDelegate::EventsNS::Events
01929 {
01930 public:
01931 };
01932 
01933 }
01934 
01935 }
01936 
01937 namespace IceDelegateM
01938 {
01939 
01940 namespace EventsNS
01941 {
01942 
01943 class Event : virtual public ::IceDelegate::EventsNS::Event,
01944               virtual public ::IceDelegateM::Ice::Object
01945 {
01946 public:
01947 };
01948 
01949 class Message1 : virtual public ::IceDelegate::EventsNS::Message1,
01950                  virtual public ::IceDelegateM::EventsNS::Event
01951 {
01952 public:
01953 };
01954 
01955 class Message2 : virtual public ::IceDelegate::EventsNS::Message2,
01956                  virtual public ::IceDelegateM::EventsNS::Event
01957 {
01958 public:
01959 };
01960 
01961 class Events : virtual public ::IceDelegate::EventsNS::Events,
01962                virtual public ::IceDelegateM::Ice::Object
01963 {
01964 public:
01965 
01966     virtual void evolve(const ::EventsNS::EventPtr&, const ::Ice::Context*);
01967 };
01968 
01969 }
01970 
01971 namespace TestPub
01972 {
01973 
01974 class Publisher1 : virtual public ::IceDelegate::TestPub::Publisher1,
01975                    virtual public ::IceDelegateM::EventsNS::Events
01976 {
01977 public:
01978 };
01979 
01980 class Publisher2 : virtual public ::IceDelegate::TestPub::Publisher2,
01981                    virtual public ::IceDelegateM::EventsNS::Events
01982 {
01983 public:
01984 };
01985 
01986 class Subscriber1 : virtual public ::IceDelegate::TestPub::Subscriber1,
01987                     virtual public ::IceDelegateM::EventsNS::Events
01988 {
01989 public:
01990 };
01991 
01992 class Subscriber2 : virtual public ::IceDelegate::TestPub::Subscriber2,
01993                     virtual public ::IceDelegateM::EventsNS::Events
01994 {
01995 public:
01996 };
01997 
01998 }
01999 
02000 }
02001 
02002 namespace IceDelegateD
02003 {
02004 
02005 namespace EventsNS
02006 {
02007 
02008 class Event : virtual public ::IceDelegate::EventsNS::Event,
02009               virtual public ::IceDelegateD::Ice::Object
02010 {
02011 public:
02012 };
02013 
02014 class Message1 : virtual public ::IceDelegate::EventsNS::Message1,
02015                  virtual public ::IceDelegateD::EventsNS::Event
02016 {
02017 public:
02018 };
02019 
02020 class Message2 : virtual public ::IceDelegate::EventsNS::Message2,
02021                  virtual public ::IceDelegateD::EventsNS::Event
02022 {
02023 public:
02024 };
02025 
02026 class Events : virtual public ::IceDelegate::EventsNS::Events,
02027                virtual public ::IceDelegateD::Ice::Object
02028 {
02029 public:
02030 
02031     virtual void evolve(const ::EventsNS::EventPtr&, const ::Ice::Context*);
02032 };
02033 
02034 }
02035 
02036 namespace TestPub
02037 {
02038 
02039 class Publisher1 : virtual public ::IceDelegate::TestPub::Publisher1,
02040                    virtual public ::IceDelegateD::EventsNS::Events
02041 {
02042 public:
02043 };
02044 
02045 class Publisher2 : virtual public ::IceDelegate::TestPub::Publisher2,
02046                    virtual public ::IceDelegateD::EventsNS::Events
02047 {
02048 public:
02049 };
02050 
02051 class Subscriber1 : virtual public ::IceDelegate::TestPub::Subscriber1,
02052                     virtual public ::IceDelegateD::EventsNS::Events
02053 {
02054 public:
02055 };
02056 
02057 class Subscriber2 : virtual public ::IceDelegate::TestPub::Subscriber2,
02058                     virtual public ::IceDelegateD::EventsNS::Events
02059 {
02060 public:
02061 };
02062 
02063 }
02064 
02065 }
02066 
02067 namespace EventsNS
02068 {
02069 
02070 class Event : virtual public ::Ice::Object
02071 {
02072 public:
02073 
02074     typedef EventPrx ProxyType;
02075     typedef EventPtr PointerType;
02076 
02077     Event() {}
02078     explicit Event(::Ice::Int);
02079     virtual ::Ice::ObjectPtr ice_clone() const;
02080 
02081     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02082     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02083     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02084     static const ::std::string& ice_staticId();
02085 
02086 
02087     virtual void __write(::IceInternal::BasicStream*) const;
02088     virtual void __read(::IceInternal::BasicStream*, bool);
02089     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02090     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02091 
02092     static const ::Ice::ObjectFactoryPtr& ice_factory();
02093 
02094 protected:
02095 
02096     virtual ~Event() {}
02097 
02098     friend class Event__staticInit;
02099 
02100 public:
02101 
02102     ::Ice::Int id;
02103 };
02104 
02105 class Event__staticInit
02106 {
02107 public:
02108 
02109     ::EventsNS::Event _init;
02110 };
02111 
02112 static Event__staticInit _Event_init;
02113 
02114 class Message1 : virtual public ::EventsNS::Event
02115 {
02116 public:
02117 
02118     typedef Message1Prx ProxyType;
02119     typedef Message1Ptr PointerType;
02120 
02121     Message1() {}
02122     Message1(::Ice::Int, ::Ice::Int, const ::std::string&);
02123     virtual ::Ice::ObjectPtr ice_clone() const;
02124 
02125     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02126     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02127     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02128     static const ::std::string& ice_staticId();
02129 
02130 
02131     virtual void __write(::IceInternal::BasicStream*) const;
02132     virtual void __read(::IceInternal::BasicStream*, bool);
02133     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02134     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02135 
02136     static const ::Ice::ObjectFactoryPtr& ice_factory();
02137 
02138 protected:
02139 
02140     virtual ~Message1() {}
02141 
02142 public:
02143 
02144     ::Ice::Int m;
02145 
02146     ::std::string msg;
02147 };
02148 
02149 class Message2 : virtual public ::EventsNS::Event
02150 {
02151 public:
02152 
02153     typedef Message2Prx ProxyType;
02154     typedef Message2Ptr PointerType;
02155 
02156     Message2() {}
02157     Message2(::Ice::Int, ::Ice::Int, ::Ice::Int, const ::std::string&);
02158     virtual ::Ice::ObjectPtr ice_clone() const;
02159 
02160     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02161     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02162     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02163     static const ::std::string& ice_staticId();
02164 
02165 
02166     virtual void __write(::IceInternal::BasicStream*) const;
02167     virtual void __read(::IceInternal::BasicStream*, bool);
02168     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02169     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02170 
02171     static const ::Ice::ObjectFactoryPtr& ice_factory();
02172 
02173 protected:
02174 
02175     virtual ~Message2() {}
02176 
02177 public:
02178 
02179     ::Ice::Int i;
02180 
02181     ::Ice::Int j;
02182 
02183     ::std::string msg;
02184 };
02185 
02186 class Events : virtual public ::Ice::Object
02187 {
02188 public:
02189 
02190     typedef EventsPrx ProxyType;
02191     typedef EventsPtr PointerType;
02192 
02193     virtual ::Ice::ObjectPtr ice_clone() const;
02194 
02195     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02196     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02197     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02198     static const ::std::string& ice_staticId();
02199 
02200     virtual void evolve(const ::EventsNS::EventPtr&, const ::Ice::Current& = ::Ice::Current()) = 0;
02201     ::Ice::DispatchStatus ___evolve(::IceInternal::Incoming&, const ::Ice::Current&);
02202 
02203     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02204 
02205     virtual void __write(::IceInternal::BasicStream*) const;
02206     virtual void __read(::IceInternal::BasicStream*, bool);
02207     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02208     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02209 };
02210 
02211 }
02212 
02213 namespace TestPub
02214 {
02215 
02216 class Publisher1 : virtual public ::EventsNS::Events
02217 {
02218 public:
02219 
02220     typedef Publisher1Prx ProxyType;
02221     typedef Publisher1Ptr PointerType;
02222 
02223     virtual ::Ice::ObjectPtr ice_clone() const;
02224 
02225     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02226     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02227     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02228     static const ::std::string& ice_staticId();
02229 
02230     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02231 
02232     virtual void __write(::IceInternal::BasicStream*) const;
02233     virtual void __read(::IceInternal::BasicStream*, bool);
02234     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02235     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02236 };
02237 
02238 class Publisher2 : virtual public ::EventsNS::Events
02239 {
02240 public:
02241 
02242     typedef Publisher2Prx ProxyType;
02243     typedef Publisher2Ptr PointerType;
02244 
02245     virtual ::Ice::ObjectPtr ice_clone() const;
02246 
02247     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02248     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02249     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02250     static const ::std::string& ice_staticId();
02251 
02252     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02253 
02254     virtual void __write(::IceInternal::BasicStream*) const;
02255     virtual void __read(::IceInternal::BasicStream*, bool);
02256     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02257     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02258 };
02259 
02260 class Subscriber1 : virtual public ::EventsNS::Events
02261 {
02262 public:
02263 
02264     typedef Subscriber1Prx ProxyType;
02265     typedef Subscriber1Ptr PointerType;
02266 
02267     virtual ::Ice::ObjectPtr ice_clone() const;
02268 
02269     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02270     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02271     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02272     static const ::std::string& ice_staticId();
02273 
02274     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02275 
02276     virtual void __write(::IceInternal::BasicStream*) const;
02277     virtual void __read(::IceInternal::BasicStream*, bool);
02278     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02279     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02280 };
02281 
02282 class Subscriber2 : virtual public ::EventsNS::Events
02283 {
02284 public:
02285 
02286     typedef Subscriber2Prx ProxyType;
02287     typedef Subscriber2Ptr PointerType;
02288 
02289     virtual ::Ice::ObjectPtr ice_clone() const;
02290 
02291     virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
02292     virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
02293     virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
02294     static const ::std::string& ice_staticId();
02295 
02296     virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
02297 
02298     virtual void __write(::IceInternal::BasicStream*) const;
02299     virtual void __read(::IceInternal::BasicStream*, bool);
02300     virtual void __write(const ::Ice::OutputStreamPtr&) const;
02301     virtual void __read(const ::Ice::InputStreamPtr&, bool);
02302 };
02303 
02304 }
02305 
02306 #endif
Generated on Sun May 8 08:40:44 2011 for iLab Neuromorphic Vision Toolkit by  doxygen 1.6.3