00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056 #ifndef __DistributedMap_h__
00057 #define __DistributedMap_h__
00058
00059 #include <Ice/LocalObjectF.h>
00060 #include <Ice/ProxyF.h>
00061 #include <Ice/ObjectF.h>
00062 #include <Ice/Exception.h>
00063 #include <Ice/LocalObject.h>
00064 #include <Ice/Proxy.h>
00065 #include <Ice/Object.h>
00066 #include <Ice/Outgoing.h>
00067 #include <Ice/OutgoingAsync.h>
00068 #include <Ice/Incoming.h>
00069 #include <Ice/IncomingAsync.h>
00070 #include <Ice/Direct.h>
00071 #include <IceUtil/ScopedArray.h>
00072 #include <Ice/StreamF.h>
00073 #include <Ice/UndefSysMacros.h>
00074
00075 #ifndef ICE_IGNORE_VERSION
00076 # if ICE_INT_VERSION / 100 != 304
00077 # error Ice version mismatch!
00078 # endif
00079 # if ICE_INT_VERSION % 100 > 50
00080 # error Beta header file detected
00081 # endif
00082 # if ICE_INT_VERSION % 100 < 1
00083 # error Ice patch level mismatch!
00084 # endif
00085 #endif
00086
00087 namespace IceProxy
00088 {
00089
00090 namespace GlobalTable
00091 {
00092
00093 class DistributedMap;
00094
00095 }
00096
00097 }
00098
00099 namespace GlobalTable
00100 {
00101
00102 class DistributedMap;
00103 bool operator==(const DistributedMap&, const DistributedMap&);
00104 bool operator<(const DistributedMap&, const DistributedMap&);
00105
00106 }
00107
00108 namespace IceInternal
00109 {
00110
00111 ::Ice::Object* upCast(::GlobalTable::DistributedMap*);
00112 ::IceProxy::Ice::Object* upCast(::IceProxy::GlobalTable::DistributedMap*);
00113
00114 }
00115
00116 namespace GlobalTable
00117 {
00118
00119 typedef ::IceInternal::Handle< ::GlobalTable::DistributedMap> DistributedMapPtr;
00120 typedef ::IceInternal::ProxyHandle< ::IceProxy::GlobalTable::DistributedMap> DistributedMapPrx;
00121
00122 void __read(::IceInternal::BasicStream*, DistributedMapPrx&);
00123 void __patch__DistributedMapPtr(void*, ::Ice::ObjectPtr&);
00124
00125 }
00126
00127 namespace GlobalTable
00128 {
00129
00130 class AMD_DistributedMap_putNget : virtual public ::Ice::AMDCallback
00131 {
00132 public:
00133
00134 virtual void ice_response(const ::std::string&) = 0;
00135 };
00136
00137 typedef ::IceUtil::Handle< ::GlobalTable::AMD_DistributedMap_putNget> AMD_DistributedMap_putNgetPtr;
00138
00139 class AMD_DistributedMap_waitForAllClients : virtual public ::Ice::AMDCallback
00140 {
00141 public:
00142
00143 virtual void ice_response() = 0;
00144 };
00145
00146 typedef ::IceUtil::Handle< ::GlobalTable::AMD_DistributedMap_waitForAllClients> AMD_DistributedMap_waitForAllClientsPtr;
00147
00148 }
00149
00150 namespace IceAsync
00151 {
00152
00153 namespace GlobalTable
00154 {
00155
00156 class AMD_DistributedMap_putNget : public ::GlobalTable::AMD_DistributedMap_putNget, public ::IceInternal::IncomingAsync
00157 {
00158 public:
00159
00160 AMD_DistributedMap_putNget(::IceInternal::Incoming&);
00161
00162 virtual void ice_response(const ::std::string&);
00163 };
00164
00165 class AMD_DistributedMap_waitForAllClients : public ::GlobalTable::AMD_DistributedMap_waitForAllClients, public ::IceInternal::IncomingAsync
00166 {
00167 public:
00168
00169 AMD_DistributedMap_waitForAllClients(::IceInternal::Incoming&);
00170
00171 virtual void ice_response();
00172 };
00173
00174 }
00175
00176 }
00177
00178 namespace GlobalTable
00179 {
00180
00181 class Callback_DistributedMap_put_Base : virtual public ::IceInternal::CallbackBase { };
00182 typedef ::IceUtil::Handle< Callback_DistributedMap_put_Base> Callback_DistributedMap_putPtr;
00183
00184 class Callback_DistributedMap_set_Base : virtual public ::IceInternal::CallbackBase { };
00185 typedef ::IceUtil::Handle< Callback_DistributedMap_set_Base> Callback_DistributedMap_setPtr;
00186
00187 class Callback_DistributedMap_remove_Base : virtual public ::IceInternal::CallbackBase { };
00188 typedef ::IceUtil::Handle< Callback_DistributedMap_remove_Base> Callback_DistributedMap_removePtr;
00189
00190 class Callback_DistributedMap_putNget_Base : virtual public ::IceInternal::CallbackBase { };
00191 typedef ::IceUtil::Handle< Callback_DistributedMap_putNget_Base> Callback_DistributedMap_putNgetPtr;
00192
00193 class Callback_DistributedMap_get_Base : virtual public ::IceInternal::CallbackBase { };
00194 typedef ::IceUtil::Handle< Callback_DistributedMap_get_Base> Callback_DistributedMap_getPtr;
00195
00196 class Callback_DistributedMap_waitForAllClients_Base : virtual public ::IceInternal::CallbackBase { };
00197 typedef ::IceUtil::Handle< Callback_DistributedMap_waitForAllClients_Base> Callback_DistributedMap_waitForAllClientsPtr;
00198
00199 }
00200
00201 namespace IceProxy
00202 {
00203
00204 namespace GlobalTable
00205 {
00206
00207 class DistributedMap : virtual public ::IceProxy::Ice::Object
00208 {
00209 public:
00210
00211 void put(const ::std::string& s, const ::std::string& delta)
00212 {
00213 put(s, delta, 0);
00214 }
00215 void put(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx)
00216 {
00217 put(s, delta, &__ctx);
00218 }
00219
00220 ::Ice::AsyncResultPtr begin_put(const ::std::string& s, const ::std::string& delta)
00221 {
00222 return begin_put(s, delta, 0, ::IceInternal::__dummyCallback, 0);
00223 }
00224
00225 ::Ice::AsyncResultPtr begin_put(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx)
00226 {
00227 return begin_put(s, delta, &__ctx, ::IceInternal::__dummyCallback, 0);
00228 }
00229
00230 ::Ice::AsyncResultPtr begin_put(const ::std::string& s, const ::std::string& delta, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00231 {
00232 return begin_put(s, delta, 0, __del, __cookie);
00233 }
00234
00235 ::Ice::AsyncResultPtr begin_put(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00236 {
00237 return begin_put(s, delta, &__ctx, __del, __cookie);
00238 }
00239
00240 ::Ice::AsyncResultPtr begin_put(const ::std::string& s, const ::std::string& delta, const ::GlobalTable::Callback_DistributedMap_putPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00241 {
00242 return begin_put(s, delta, 0, __del, __cookie);
00243 }
00244
00245 ::Ice::AsyncResultPtr begin_put(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx, const ::GlobalTable::Callback_DistributedMap_putPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00246 {
00247 return begin_put(s, delta, &__ctx, __del, __cookie);
00248 }
00249
00250 void end_put(const ::Ice::AsyncResultPtr&);
00251
00252 private:
00253
00254 void put(const ::std::string&, const ::std::string&, const ::Ice::Context*);
00255 ::Ice::AsyncResultPtr begin_put(const ::std::string&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
00256
00257 public:
00258
00259 void set(const ::std::string& s, const ::std::string& counts)
00260 {
00261 set(s, counts, 0);
00262 }
00263 void set(const ::std::string& s, const ::std::string& counts, const ::Ice::Context& __ctx)
00264 {
00265 set(s, counts, &__ctx);
00266 }
00267
00268 ::Ice::AsyncResultPtr begin_set(const ::std::string& s, const ::std::string& counts)
00269 {
00270 return begin_set(s, counts, 0, ::IceInternal::__dummyCallback, 0);
00271 }
00272
00273 ::Ice::AsyncResultPtr begin_set(const ::std::string& s, const ::std::string& counts, const ::Ice::Context& __ctx)
00274 {
00275 return begin_set(s, counts, &__ctx, ::IceInternal::__dummyCallback, 0);
00276 }
00277
00278 ::Ice::AsyncResultPtr begin_set(const ::std::string& s, const ::std::string& counts, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00279 {
00280 return begin_set(s, counts, 0, __del, __cookie);
00281 }
00282
00283 ::Ice::AsyncResultPtr begin_set(const ::std::string& s, const ::std::string& counts, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00284 {
00285 return begin_set(s, counts, &__ctx, __del, __cookie);
00286 }
00287
00288 ::Ice::AsyncResultPtr begin_set(const ::std::string& s, const ::std::string& counts, const ::GlobalTable::Callback_DistributedMap_setPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00289 {
00290 return begin_set(s, counts, 0, __del, __cookie);
00291 }
00292
00293 ::Ice::AsyncResultPtr begin_set(const ::std::string& s, const ::std::string& counts, const ::Ice::Context& __ctx, const ::GlobalTable::Callback_DistributedMap_setPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00294 {
00295 return begin_set(s, counts, &__ctx, __del, __cookie);
00296 }
00297
00298 void end_set(const ::Ice::AsyncResultPtr&);
00299
00300 private:
00301
00302 void set(const ::std::string&, const ::std::string&, const ::Ice::Context*);
00303 ::Ice::AsyncResultPtr begin_set(const ::std::string&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
00304
00305 public:
00306
00307 bool remove(const ::std::string& s, ::std::string& counts)
00308 {
00309 return remove(s, counts, 0);
00310 }
00311 bool remove(const ::std::string& s, ::std::string& counts, const ::Ice::Context& __ctx)
00312 {
00313 return remove(s, counts, &__ctx);
00314 }
00315
00316 ::Ice::AsyncResultPtr begin_remove(const ::std::string& s)
00317 {
00318 return begin_remove(s, 0, ::IceInternal::__dummyCallback, 0);
00319 }
00320
00321 ::Ice::AsyncResultPtr begin_remove(const ::std::string& s, const ::Ice::Context& __ctx)
00322 {
00323 return begin_remove(s, &__ctx, ::IceInternal::__dummyCallback, 0);
00324 }
00325
00326 ::Ice::AsyncResultPtr begin_remove(const ::std::string& s, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00327 {
00328 return begin_remove(s, 0, __del, __cookie);
00329 }
00330
00331 ::Ice::AsyncResultPtr begin_remove(const ::std::string& s, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00332 {
00333 return begin_remove(s, &__ctx, __del, __cookie);
00334 }
00335
00336 ::Ice::AsyncResultPtr begin_remove(const ::std::string& s, const ::GlobalTable::Callback_DistributedMap_removePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00337 {
00338 return begin_remove(s, 0, __del, __cookie);
00339 }
00340
00341 ::Ice::AsyncResultPtr begin_remove(const ::std::string& s, const ::Ice::Context& __ctx, const ::GlobalTable::Callback_DistributedMap_removePtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00342 {
00343 return begin_remove(s, &__ctx, __del, __cookie);
00344 }
00345
00346 bool end_remove(::std::string& counts, const ::Ice::AsyncResultPtr&);
00347
00348 private:
00349
00350 bool remove(const ::std::string&, ::std::string&, const ::Ice::Context*);
00351 ::Ice::AsyncResultPtr begin_remove(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
00352
00353 public:
00354
00355 void putNget(const ::std::string& s, const ::std::string& delta, ::std::string& counts)
00356 {
00357 putNget(s, delta, counts, 0);
00358 }
00359 void putNget(const ::std::string& s, const ::std::string& delta, ::std::string& counts, const ::Ice::Context& __ctx)
00360 {
00361 putNget(s, delta, counts, &__ctx);
00362 }
00363
00364 ::Ice::AsyncResultPtr begin_putNget(const ::std::string& s, const ::std::string& delta)
00365 {
00366 return begin_putNget(s, delta, 0, ::IceInternal::__dummyCallback, 0);
00367 }
00368
00369 ::Ice::AsyncResultPtr begin_putNget(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx)
00370 {
00371 return begin_putNget(s, delta, &__ctx, ::IceInternal::__dummyCallback, 0);
00372 }
00373
00374 ::Ice::AsyncResultPtr begin_putNget(const ::std::string& s, const ::std::string& delta, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00375 {
00376 return begin_putNget(s, delta, 0, __del, __cookie);
00377 }
00378
00379 ::Ice::AsyncResultPtr begin_putNget(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00380 {
00381 return begin_putNget(s, delta, &__ctx, __del, __cookie);
00382 }
00383
00384 ::Ice::AsyncResultPtr begin_putNget(const ::std::string& s, const ::std::string& delta, const ::GlobalTable::Callback_DistributedMap_putNgetPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00385 {
00386 return begin_putNget(s, delta, 0, __del, __cookie);
00387 }
00388
00389 ::Ice::AsyncResultPtr begin_putNget(const ::std::string& s, const ::std::string& delta, const ::Ice::Context& __ctx, const ::GlobalTable::Callback_DistributedMap_putNgetPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00390 {
00391 return begin_putNget(s, delta, &__ctx, __del, __cookie);
00392 }
00393
00394 void end_putNget(::std::string& counts, const ::Ice::AsyncResultPtr&);
00395
00396 private:
00397
00398 void putNget(const ::std::string&, const ::std::string&, ::std::string&, const ::Ice::Context*);
00399 ::Ice::AsyncResultPtr begin_putNget(const ::std::string&, const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
00400
00401 public:
00402
00403 bool get(const ::std::string& s, ::std::string& counts)
00404 {
00405 return get(s, counts, 0);
00406 }
00407 bool get(const ::std::string& s, ::std::string& counts, const ::Ice::Context& __ctx)
00408 {
00409 return get(s, counts, &__ctx);
00410 }
00411
00412 ::Ice::AsyncResultPtr begin_get(const ::std::string& s)
00413 {
00414 return begin_get(s, 0, ::IceInternal::__dummyCallback, 0);
00415 }
00416
00417 ::Ice::AsyncResultPtr begin_get(const ::std::string& s, const ::Ice::Context& __ctx)
00418 {
00419 return begin_get(s, &__ctx, ::IceInternal::__dummyCallback, 0);
00420 }
00421
00422 ::Ice::AsyncResultPtr begin_get(const ::std::string& s, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00423 {
00424 return begin_get(s, 0, __del, __cookie);
00425 }
00426
00427 ::Ice::AsyncResultPtr begin_get(const ::std::string& s, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00428 {
00429 return begin_get(s, &__ctx, __del, __cookie);
00430 }
00431
00432 ::Ice::AsyncResultPtr begin_get(const ::std::string& s, const ::GlobalTable::Callback_DistributedMap_getPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00433 {
00434 return begin_get(s, 0, __del, __cookie);
00435 }
00436
00437 ::Ice::AsyncResultPtr begin_get(const ::std::string& s, const ::Ice::Context& __ctx, const ::GlobalTable::Callback_DistributedMap_getPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00438 {
00439 return begin_get(s, &__ctx, __del, __cookie);
00440 }
00441
00442 bool end_get(::std::string& counts, const ::Ice::AsyncResultPtr&);
00443
00444 private:
00445
00446 bool get(const ::std::string&, ::std::string&, const ::Ice::Context*);
00447 ::Ice::AsyncResultPtr begin_get(const ::std::string&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
00448
00449 public:
00450
00451 void waitForAllClients()
00452 {
00453 waitForAllClients(0);
00454 }
00455 void waitForAllClients(const ::Ice::Context& __ctx)
00456 {
00457 waitForAllClients(&__ctx);
00458 }
00459
00460 ::Ice::AsyncResultPtr begin_waitForAllClients()
00461 {
00462 return begin_waitForAllClients(0, ::IceInternal::__dummyCallback, 0);
00463 }
00464
00465 ::Ice::AsyncResultPtr begin_waitForAllClients(const ::Ice::Context& __ctx)
00466 {
00467 return begin_waitForAllClients(&__ctx, ::IceInternal::__dummyCallback, 0);
00468 }
00469
00470 ::Ice::AsyncResultPtr begin_waitForAllClients(const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00471 {
00472 return begin_waitForAllClients(0, __del, __cookie);
00473 }
00474
00475 ::Ice::AsyncResultPtr begin_waitForAllClients(const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00476 {
00477 return begin_waitForAllClients(&__ctx, __del, __cookie);
00478 }
00479
00480 ::Ice::AsyncResultPtr begin_waitForAllClients(const ::GlobalTable::Callback_DistributedMap_waitForAllClientsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00481 {
00482 return begin_waitForAllClients(0, __del, __cookie);
00483 }
00484
00485 ::Ice::AsyncResultPtr begin_waitForAllClients(const ::Ice::Context& __ctx, const ::GlobalTable::Callback_DistributedMap_waitForAllClientsPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
00486 {
00487 return begin_waitForAllClients(&__ctx, __del, __cookie);
00488 }
00489
00490 void end_waitForAllClients(const ::Ice::AsyncResultPtr&);
00491
00492 private:
00493
00494 void waitForAllClients(const ::Ice::Context*);
00495 ::Ice::AsyncResultPtr begin_waitForAllClients(const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
00496
00497 public:
00498
00499 ::IceInternal::ProxyHandle<DistributedMap> ice_context(const ::Ice::Context& __context) const
00500 {
00501 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00502 typedef ::IceProxy::Ice::Object _Base;
00503 return dynamic_cast<DistributedMap*>(_Base::ice_context(__context).get());
00504 #else
00505 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_context(__context).get());
00506 #endif
00507 }
00508
00509 ::IceInternal::ProxyHandle<DistributedMap> ice_adapterId(const std::string& __id) const
00510 {
00511 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00512 typedef ::IceProxy::Ice::Object _Base;
00513 return dynamic_cast<DistributedMap*>(_Base::ice_adapterId(__id).get());
00514 #else
00515 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
00516 #endif
00517 }
00518
00519 ::IceInternal::ProxyHandle<DistributedMap> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
00520 {
00521 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00522 typedef ::IceProxy::Ice::Object _Base;
00523 return dynamic_cast<DistributedMap*>(_Base::ice_endpoints(__endpoints).get());
00524 #else
00525 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
00526 #endif
00527 }
00528
00529 ::IceInternal::ProxyHandle<DistributedMap> ice_locatorCacheTimeout(int __timeout) const
00530 {
00531 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00532 typedef ::IceProxy::Ice::Object _Base;
00533 return dynamic_cast<DistributedMap*>(_Base::ice_locatorCacheTimeout(__timeout).get());
00534 #else
00535 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
00536 #endif
00537 }
00538
00539 ::IceInternal::ProxyHandle<DistributedMap> ice_connectionCached(bool __cached) const
00540 {
00541 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00542 typedef ::IceProxy::Ice::Object _Base;
00543 return dynamic_cast<DistributedMap*>(_Base::ice_connectionCached(__cached).get());
00544 #else
00545 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
00546 #endif
00547 }
00548
00549 ::IceInternal::ProxyHandle<DistributedMap> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
00550 {
00551 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00552 typedef ::IceProxy::Ice::Object _Base;
00553 return dynamic_cast<DistributedMap*>(_Base::ice_endpointSelection(__est).get());
00554 #else
00555 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
00556 #endif
00557 }
00558
00559 ::IceInternal::ProxyHandle<DistributedMap> ice_secure(bool __secure) const
00560 {
00561 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00562 typedef ::IceProxy::Ice::Object _Base;
00563 return dynamic_cast<DistributedMap*>(_Base::ice_secure(__secure).get());
00564 #else
00565 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
00566 #endif
00567 }
00568
00569 ::IceInternal::ProxyHandle<DistributedMap> ice_preferSecure(bool __preferSecure) const
00570 {
00571 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00572 typedef ::IceProxy::Ice::Object _Base;
00573 return dynamic_cast<DistributedMap*>(_Base::ice_preferSecure(__preferSecure).get());
00574 #else
00575 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
00576 #endif
00577 }
00578
00579 ::IceInternal::ProxyHandle<DistributedMap> ice_router(const ::Ice::RouterPrx& __router) const
00580 {
00581 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00582 typedef ::IceProxy::Ice::Object _Base;
00583 return dynamic_cast<DistributedMap*>(_Base::ice_router(__router).get());
00584 #else
00585 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_router(__router).get());
00586 #endif
00587 }
00588
00589 ::IceInternal::ProxyHandle<DistributedMap> ice_locator(const ::Ice::LocatorPrx& __locator) const
00590 {
00591 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00592 typedef ::IceProxy::Ice::Object _Base;
00593 return dynamic_cast<DistributedMap*>(_Base::ice_locator(__locator).get());
00594 #else
00595 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
00596 #endif
00597 }
00598
00599 ::IceInternal::ProxyHandle<DistributedMap> ice_collocationOptimized(bool __co) const
00600 {
00601 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00602 typedef ::IceProxy::Ice::Object _Base;
00603 return dynamic_cast<DistributedMap*>(_Base::ice_collocationOptimized(__co).get());
00604 #else
00605 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
00606 #endif
00607 }
00608
00609 ::IceInternal::ProxyHandle<DistributedMap> ice_twoway() const
00610 {
00611 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00612 typedef ::IceProxy::Ice::Object _Base;
00613 return dynamic_cast<DistributedMap*>(_Base::ice_twoway().get());
00614 #else
00615 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_twoway().get());
00616 #endif
00617 }
00618
00619 ::IceInternal::ProxyHandle<DistributedMap> ice_oneway() const
00620 {
00621 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00622 typedef ::IceProxy::Ice::Object _Base;
00623 return dynamic_cast<DistributedMap*>(_Base::ice_oneway().get());
00624 #else
00625 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_oneway().get());
00626 #endif
00627 }
00628
00629 ::IceInternal::ProxyHandle<DistributedMap> ice_batchOneway() const
00630 {
00631 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00632 typedef ::IceProxy::Ice::Object _Base;
00633 return dynamic_cast<DistributedMap*>(_Base::ice_batchOneway().get());
00634 #else
00635 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_batchOneway().get());
00636 #endif
00637 }
00638
00639 ::IceInternal::ProxyHandle<DistributedMap> ice_datagram() const
00640 {
00641 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00642 typedef ::IceProxy::Ice::Object _Base;
00643 return dynamic_cast<DistributedMap*>(_Base::ice_datagram().get());
00644 #else
00645 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_datagram().get());
00646 #endif
00647 }
00648
00649 ::IceInternal::ProxyHandle<DistributedMap> ice_batchDatagram() const
00650 {
00651 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00652 typedef ::IceProxy::Ice::Object _Base;
00653 return dynamic_cast<DistributedMap*>(_Base::ice_batchDatagram().get());
00654 #else
00655 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
00656 #endif
00657 }
00658
00659 ::IceInternal::ProxyHandle<DistributedMap> ice_compress(bool __compress) const
00660 {
00661 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00662 typedef ::IceProxy::Ice::Object _Base;
00663 return dynamic_cast<DistributedMap*>(_Base::ice_compress(__compress).get());
00664 #else
00665 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
00666 #endif
00667 }
00668
00669 ::IceInternal::ProxyHandle<DistributedMap> ice_timeout(int __timeout) const
00670 {
00671 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00672 typedef ::IceProxy::Ice::Object _Base;
00673 return dynamic_cast<DistributedMap*>(_Base::ice_timeout(__timeout).get());
00674 #else
00675 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
00676 #endif
00677 }
00678
00679 ::IceInternal::ProxyHandle<DistributedMap> ice_connectionId(const std::string& __id) const
00680 {
00681 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
00682 typedef ::IceProxy::Ice::Object _Base;
00683 return dynamic_cast<DistributedMap*>(_Base::ice_connectionId(__id).get());
00684 #else
00685 return dynamic_cast<DistributedMap*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
00686 #endif
00687 }
00688
00689 static const ::std::string& ice_staticId();
00690
00691 private:
00692
00693 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
00694 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
00695 virtual ::IceProxy::Ice::Object* __newInstance() const;
00696 };
00697
00698 }
00699
00700 }
00701
00702 namespace IceDelegate
00703 {
00704
00705 namespace GlobalTable
00706 {
00707
00708 class DistributedMap : virtual public ::IceDelegate::Ice::Object
00709 {
00710 public:
00711
00712 virtual void put(const ::std::string&, const ::std::string&, const ::Ice::Context*) = 0;
00713
00714 virtual void set(const ::std::string&, const ::std::string&, const ::Ice::Context*) = 0;
00715
00716 virtual bool remove(const ::std::string&, ::std::string&, const ::Ice::Context*) = 0;
00717
00718 virtual void putNget(const ::std::string&, const ::std::string&, ::std::string&, const ::Ice::Context*) = 0;
00719
00720 virtual bool get(const ::std::string&, ::std::string&, const ::Ice::Context*) = 0;
00721
00722 virtual void waitForAllClients(const ::Ice::Context*) = 0;
00723 };
00724
00725 }
00726
00727 }
00728
00729 namespace IceDelegateM
00730 {
00731
00732 namespace GlobalTable
00733 {
00734
00735 class DistributedMap : virtual public ::IceDelegate::GlobalTable::DistributedMap,
00736 virtual public ::IceDelegateM::Ice::Object
00737 {
00738 public:
00739
00740 virtual void put(const ::std::string&, const ::std::string&, const ::Ice::Context*);
00741
00742 virtual void set(const ::std::string&, const ::std::string&, const ::Ice::Context*);
00743
00744 virtual bool remove(const ::std::string&, ::std::string&, const ::Ice::Context*);
00745
00746 virtual void putNget(const ::std::string&, const ::std::string&, ::std::string&, const ::Ice::Context*);
00747
00748 virtual bool get(const ::std::string&, ::std::string&, const ::Ice::Context*);
00749
00750 virtual void waitForAllClients(const ::Ice::Context*);
00751 };
00752
00753 }
00754
00755 }
00756
00757 namespace IceDelegateD
00758 {
00759
00760 namespace GlobalTable
00761 {
00762
00763 class DistributedMap : virtual public ::IceDelegate::GlobalTable::DistributedMap,
00764 virtual public ::IceDelegateD::Ice::Object
00765 {
00766 public:
00767
00768 virtual void put(const ::std::string&, const ::std::string&, const ::Ice::Context*);
00769
00770 virtual void set(const ::std::string&, const ::std::string&, const ::Ice::Context*);
00771
00772 virtual bool remove(const ::std::string&, ::std::string&, const ::Ice::Context*);
00773
00774 virtual void putNget(const ::std::string&, const ::std::string&, ::std::string&, const ::Ice::Context*);
00775
00776 virtual bool get(const ::std::string&, ::std::string&, const ::Ice::Context*);
00777
00778 virtual void waitForAllClients(const ::Ice::Context*);
00779 };
00780
00781 }
00782
00783 }
00784
00785 namespace GlobalTable
00786 {
00787
00788 class DistributedMap : virtual public ::Ice::Object
00789 {
00790 public:
00791
00792 typedef DistributedMapPrx ProxyType;
00793 typedef DistributedMapPtr PointerType;
00794
00795 virtual ::Ice::ObjectPtr ice_clone() const;
00796
00797 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
00798 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
00799 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
00800 static const ::std::string& ice_staticId();
00801
00802 virtual void put(const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
00803 ::Ice::DispatchStatus ___put(::IceInternal::Incoming&, const ::Ice::Current&);
00804
00805 virtual void set(const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
00806 ::Ice::DispatchStatus ___set(::IceInternal::Incoming&, const ::Ice::Current&);
00807
00808 virtual bool remove(const ::std::string&, ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
00809 ::Ice::DispatchStatus ___remove(::IceInternal::Incoming&, const ::Ice::Current&);
00810
00811 virtual void putNget_async(const ::GlobalTable::AMD_DistributedMap_putNgetPtr&, const ::std::string&, const ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
00812 ::Ice::DispatchStatus ___putNget(::IceInternal::Incoming&, const ::Ice::Current&);
00813
00814 virtual bool get(const ::std::string&, ::std::string&, const ::Ice::Current& = ::Ice::Current()) = 0;
00815 ::Ice::DispatchStatus ___get(::IceInternal::Incoming&, const ::Ice::Current&);
00816
00817 virtual void waitForAllClients_async(const ::GlobalTable::AMD_DistributedMap_waitForAllClientsPtr&, const ::Ice::Current& = ::Ice::Current()) = 0;
00818 ::Ice::DispatchStatus ___waitForAllClients(::IceInternal::Incoming&, const ::Ice::Current&);
00819
00820 virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
00821
00822 virtual void __write(::IceInternal::BasicStream*) const;
00823 virtual void __read(::IceInternal::BasicStream*, bool);
00824
00825 #if !defined(_MSC_VER) || (_MSC_VER >= 1300)
00826 virtual void __write(const ::Ice::OutputStreamPtr&) const;
00827 virtual void __read(const ::Ice::InputStreamPtr&, bool);
00828 #endif
00829 };
00830
00831 inline bool operator==(const DistributedMap& l, const DistributedMap& r)
00832 {
00833 return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
00834 }
00835
00836 inline bool operator<(const DistributedMap& l, const DistributedMap& r)
00837 {
00838 return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
00839 }
00840
00841 }
00842
00843 namespace GlobalTable
00844 {
00845
00846 template<class T>
00847 class CallbackNC_DistributedMap_put : public Callback_DistributedMap_put_Base, public ::IceInternal::OnewayCallbackNC<T>
00848 {
00849 public:
00850
00851 typedef IceUtil::Handle<T> TPtr;
00852
00853 typedef void (T::*Exception)(const ::Ice::Exception&);
00854 typedef void (T::*Sent)(bool);
00855 typedef void (T::*Response)();
00856
00857 CallbackNC_DistributedMap_put(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
00858 : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
00859 {
00860 }
00861 };
00862
00863 template<class T> Callback_DistributedMap_putPtr
00864 newCallback_DistributedMap_put(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00865 {
00866 return new CallbackNC_DistributedMap_put<T>(instance, cb, excb, sentcb);
00867 }
00868
00869 template<class T> Callback_DistributedMap_putPtr
00870 newCallback_DistributedMap_put(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00871 {
00872 return new CallbackNC_DistributedMap_put<T>(instance, 0, excb, sentcb);
00873 }
00874
00875 template<class T> Callback_DistributedMap_putPtr
00876 newCallback_DistributedMap_put(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00877 {
00878 return new CallbackNC_DistributedMap_put<T>(instance, cb, excb, sentcb);
00879 }
00880
00881 template<class T> Callback_DistributedMap_putPtr
00882 newCallback_DistributedMap_put(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00883 {
00884 return new CallbackNC_DistributedMap_put<T>(instance, 0, excb, sentcb);
00885 }
00886
00887 template<class T, typename CT>
00888 class Callback_DistributedMap_put : public Callback_DistributedMap_put_Base, public ::IceInternal::OnewayCallback<T, CT>
00889 {
00890 public:
00891
00892 typedef IceUtil::Handle<T> TPtr;
00893
00894 typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
00895 typedef void (T::*Sent)(bool , const CT&);
00896 typedef void (T::*Response)(const CT&);
00897
00898 Callback_DistributedMap_put(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
00899 : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
00900 {
00901 }
00902 };
00903
00904 template<class T, typename CT> Callback_DistributedMap_putPtr
00905 newCallback_DistributedMap_put(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
00906 {
00907 return new Callback_DistributedMap_put<T, CT>(instance, cb, excb, sentcb);
00908 }
00909
00910 template<class T, typename CT> Callback_DistributedMap_putPtr
00911 newCallback_DistributedMap_put(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
00912 {
00913 return new Callback_DistributedMap_put<T, CT>(instance, 0, excb, sentcb);
00914 }
00915
00916 template<class T, typename CT> Callback_DistributedMap_putPtr
00917 newCallback_DistributedMap_put(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
00918 {
00919 return new Callback_DistributedMap_put<T, CT>(instance, cb, excb, sentcb);
00920 }
00921
00922 template<class T, typename CT> Callback_DistributedMap_putPtr
00923 newCallback_DistributedMap_put(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
00924 {
00925 return new Callback_DistributedMap_put<T, CT>(instance, 0, excb, sentcb);
00926 }
00927
00928 template<class T>
00929 class CallbackNC_DistributedMap_set : public Callback_DistributedMap_set_Base, public ::IceInternal::OnewayCallbackNC<T>
00930 {
00931 public:
00932
00933 typedef IceUtil::Handle<T> TPtr;
00934
00935 typedef void (T::*Exception)(const ::Ice::Exception&);
00936 typedef void (T::*Sent)(bool);
00937 typedef void (T::*Response)();
00938
00939 CallbackNC_DistributedMap_set(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
00940 : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
00941 {
00942 }
00943 };
00944
00945 template<class T> Callback_DistributedMap_setPtr
00946 newCallback_DistributedMap_set(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00947 {
00948 return new CallbackNC_DistributedMap_set<T>(instance, cb, excb, sentcb);
00949 }
00950
00951 template<class T> Callback_DistributedMap_setPtr
00952 newCallback_DistributedMap_set(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00953 {
00954 return new CallbackNC_DistributedMap_set<T>(instance, 0, excb, sentcb);
00955 }
00956
00957 template<class T> Callback_DistributedMap_setPtr
00958 newCallback_DistributedMap_set(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00959 {
00960 return new CallbackNC_DistributedMap_set<T>(instance, cb, excb, sentcb);
00961 }
00962
00963 template<class T> Callback_DistributedMap_setPtr
00964 newCallback_DistributedMap_set(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
00965 {
00966 return new CallbackNC_DistributedMap_set<T>(instance, 0, excb, sentcb);
00967 }
00968
00969 template<class T, typename CT>
00970 class Callback_DistributedMap_set : public Callback_DistributedMap_set_Base, public ::IceInternal::OnewayCallback<T, CT>
00971 {
00972 public:
00973
00974 typedef IceUtil::Handle<T> TPtr;
00975
00976 typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
00977 typedef void (T::*Sent)(bool , const CT&);
00978 typedef void (T::*Response)(const CT&);
00979
00980 Callback_DistributedMap_set(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
00981 : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
00982 {
00983 }
00984 };
00985
00986 template<class T, typename CT> Callback_DistributedMap_setPtr
00987 newCallback_DistributedMap_set(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
00988 {
00989 return new Callback_DistributedMap_set<T, CT>(instance, cb, excb, sentcb);
00990 }
00991
00992 template<class T, typename CT> Callback_DistributedMap_setPtr
00993 newCallback_DistributedMap_set(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
00994 {
00995 return new Callback_DistributedMap_set<T, CT>(instance, 0, excb, sentcb);
00996 }
00997
00998 template<class T, typename CT> Callback_DistributedMap_setPtr
00999 newCallback_DistributedMap_set(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01000 {
01001 return new Callback_DistributedMap_set<T, CT>(instance, cb, excb, sentcb);
01002 }
01003
01004 template<class T, typename CT> Callback_DistributedMap_setPtr
01005 newCallback_DistributedMap_set(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01006 {
01007 return new Callback_DistributedMap_set<T, CT>(instance, 0, excb, sentcb);
01008 }
01009
01010 template<class T>
01011 class CallbackNC_DistributedMap_remove : public Callback_DistributedMap_remove_Base, public ::IceInternal::TwowayCallbackNC<T>
01012 {
01013 public:
01014
01015 typedef IceUtil::Handle<T> TPtr;
01016
01017 typedef void (T::*Exception)(const ::Ice::Exception&);
01018 typedef void (T::*Sent)(bool);
01019 typedef void (T::*Response)(bool, const ::std::string&);
01020
01021 CallbackNC_DistributedMap_remove(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01022 : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
01023 {
01024 }
01025
01026 virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
01027 {
01028 ::GlobalTable::DistributedMapPrx __proxy = ::GlobalTable::DistributedMapPrx::uncheckedCast(__result->getProxy());
01029 ::std::string counts;
01030 bool __ret;
01031 try
01032 {
01033 __ret = __proxy->end_remove(counts, __result);
01034 }
01035 catch(::Ice::Exception& ex)
01036 {
01037 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01038 __exception(__result, ex);
01039 #else
01040 ::IceInternal::CallbackNC<T>::__exception(__result, ex);
01041 #endif
01042 return;
01043 }
01044 if(response)
01045 {
01046 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01047 (callback.get()->*response)(__ret, counts);
01048 #else
01049 (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret, counts);
01050 #endif
01051 }
01052 }
01053
01054 Response response;
01055 };
01056
01057 template<class T> Callback_DistributedMap_removePtr
01058 newCallback_DistributedMap_remove(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01059 {
01060 return new CallbackNC_DistributedMap_remove<T>(instance, cb, excb, sentcb);
01061 }
01062
01063 template<class T> Callback_DistributedMap_removePtr
01064 newCallback_DistributedMap_remove(T* instance, void (T::*cb)(bool, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01065 {
01066 return new CallbackNC_DistributedMap_remove<T>(instance, cb, excb, sentcb);
01067 }
01068
01069 template<class T, typename CT>
01070 class Callback_DistributedMap_remove : public Callback_DistributedMap_remove_Base, public ::IceInternal::TwowayCallback<T, CT>
01071 {
01072 public:
01073
01074 typedef IceUtil::Handle<T> TPtr;
01075
01076 typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
01077 typedef void (T::*Sent)(bool , const CT&);
01078 typedef void (T::*Response)(bool, const ::std::string&, const CT&);
01079
01080 Callback_DistributedMap_remove(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01081 : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
01082 {
01083 }
01084
01085 virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
01086 {
01087 ::GlobalTable::DistributedMapPrx __proxy = ::GlobalTable::DistributedMapPrx::uncheckedCast(__result->getProxy());
01088 ::std::string counts;
01089 bool __ret;
01090 try
01091 {
01092 __ret = __proxy->end_remove(counts, __result);
01093 }
01094 catch(::Ice::Exception& ex)
01095 {
01096 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01097 __exception(__result, ex);
01098 #else
01099 ::IceInternal::Callback<T, CT>::__exception(__result, ex);
01100 #endif
01101 return;
01102 }
01103 if(response)
01104 {
01105 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01106 (callback.get()->*response)(__ret, counts, CT::dynamicCast(__result->getCookie()));
01107 #else
01108 (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, counts, CT::dynamicCast(__result->getCookie()));
01109 #endif
01110 }
01111 }
01112
01113 Response response;
01114 };
01115
01116 template<class T, typename CT> Callback_DistributedMap_removePtr
01117 newCallback_DistributedMap_remove(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01118 {
01119 return new Callback_DistributedMap_remove<T, CT>(instance, cb, excb, sentcb);
01120 }
01121
01122 template<class T, typename CT> Callback_DistributedMap_removePtr
01123 newCallback_DistributedMap_remove(T* instance, void (T::*cb)(bool, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01124 {
01125 return new Callback_DistributedMap_remove<T, CT>(instance, cb, excb, sentcb);
01126 }
01127
01128 template<class T>
01129 class CallbackNC_DistributedMap_putNget : public Callback_DistributedMap_putNget_Base, public ::IceInternal::TwowayCallbackNC<T>
01130 {
01131 public:
01132
01133 typedef IceUtil::Handle<T> TPtr;
01134
01135 typedef void (T::*Exception)(const ::Ice::Exception&);
01136 typedef void (T::*Sent)(bool);
01137 typedef void (T::*Response)(const ::std::string&);
01138
01139 CallbackNC_DistributedMap_putNget(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01140 : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
01141 {
01142 }
01143
01144 virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
01145 {
01146 ::GlobalTable::DistributedMapPrx __proxy = ::GlobalTable::DistributedMapPrx::uncheckedCast(__result->getProxy());
01147 ::std::string counts;
01148 try
01149 {
01150 __proxy->end_putNget(counts, __result);
01151 }
01152 catch(::Ice::Exception& ex)
01153 {
01154 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01155 __exception(__result, ex);
01156 #else
01157 ::IceInternal::CallbackNC<T>::__exception(__result, ex);
01158 #endif
01159 return;
01160 }
01161 if(response)
01162 {
01163 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01164 (callback.get()->*response)(counts);
01165 #else
01166 (::IceInternal::CallbackNC<T>::callback.get()->*response)(counts);
01167 #endif
01168 }
01169 }
01170
01171 Response response;
01172 };
01173
01174 template<class T> Callback_DistributedMap_putNgetPtr
01175 newCallback_DistributedMap_putNget(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01176 {
01177 return new CallbackNC_DistributedMap_putNget<T>(instance, cb, excb, sentcb);
01178 }
01179
01180 template<class T> Callback_DistributedMap_putNgetPtr
01181 newCallback_DistributedMap_putNget(T* instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01182 {
01183 return new CallbackNC_DistributedMap_putNget<T>(instance, cb, excb, sentcb);
01184 }
01185
01186 template<class T, typename CT>
01187 class Callback_DistributedMap_putNget : public Callback_DistributedMap_putNget_Base, public ::IceInternal::TwowayCallback<T, CT>
01188 {
01189 public:
01190
01191 typedef IceUtil::Handle<T> TPtr;
01192
01193 typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
01194 typedef void (T::*Sent)(bool , const CT&);
01195 typedef void (T::*Response)(const ::std::string&, const CT&);
01196
01197 Callback_DistributedMap_putNget(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01198 : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
01199 {
01200 }
01201
01202 virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
01203 {
01204 ::GlobalTable::DistributedMapPrx __proxy = ::GlobalTable::DistributedMapPrx::uncheckedCast(__result->getProxy());
01205 ::std::string counts;
01206 try
01207 {
01208 __proxy->end_putNget(counts, __result);
01209 }
01210 catch(::Ice::Exception& ex)
01211 {
01212 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01213 __exception(__result, ex);
01214 #else
01215 ::IceInternal::Callback<T, CT>::__exception(__result, ex);
01216 #endif
01217 return;
01218 }
01219 if(response)
01220 {
01221 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01222 (callback.get()->*response)(counts, CT::dynamicCast(__result->getCookie()));
01223 #else
01224 (::IceInternal::Callback<T, CT>::callback.get()->*response)(counts, CT::dynamicCast(__result->getCookie()));
01225 #endif
01226 }
01227 }
01228
01229 Response response;
01230 };
01231
01232 template<class T, typename CT> Callback_DistributedMap_putNgetPtr
01233 newCallback_DistributedMap_putNget(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01234 {
01235 return new Callback_DistributedMap_putNget<T, CT>(instance, cb, excb, sentcb);
01236 }
01237
01238 template<class T, typename CT> Callback_DistributedMap_putNgetPtr
01239 newCallback_DistributedMap_putNget(T* instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01240 {
01241 return new Callback_DistributedMap_putNget<T, CT>(instance, cb, excb, sentcb);
01242 }
01243
01244 template<class T>
01245 class CallbackNC_DistributedMap_get : public Callback_DistributedMap_get_Base, public ::IceInternal::TwowayCallbackNC<T>
01246 {
01247 public:
01248
01249 typedef IceUtil::Handle<T> TPtr;
01250
01251 typedef void (T::*Exception)(const ::Ice::Exception&);
01252 typedef void (T::*Sent)(bool);
01253 typedef void (T::*Response)(bool, const ::std::string&);
01254
01255 CallbackNC_DistributedMap_get(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01256 : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), response(cb)
01257 {
01258 }
01259
01260 virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
01261 {
01262 ::GlobalTable::DistributedMapPrx __proxy = ::GlobalTable::DistributedMapPrx::uncheckedCast(__result->getProxy());
01263 ::std::string counts;
01264 bool __ret;
01265 try
01266 {
01267 __ret = __proxy->end_get(counts, __result);
01268 }
01269 catch(::Ice::Exception& ex)
01270 {
01271 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01272 __exception(__result, ex);
01273 #else
01274 ::IceInternal::CallbackNC<T>::__exception(__result, ex);
01275 #endif
01276 return;
01277 }
01278 if(response)
01279 {
01280 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01281 (callback.get()->*response)(__ret, counts);
01282 #else
01283 (::IceInternal::CallbackNC<T>::callback.get()->*response)(__ret, counts);
01284 #endif
01285 }
01286 }
01287
01288 Response response;
01289 };
01290
01291 template<class T> Callback_DistributedMap_getPtr
01292 newCallback_DistributedMap_get(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01293 {
01294 return new CallbackNC_DistributedMap_get<T>(instance, cb, excb, sentcb);
01295 }
01296
01297 template<class T> Callback_DistributedMap_getPtr
01298 newCallback_DistributedMap_get(T* instance, void (T::*cb)(bool, const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01299 {
01300 return new CallbackNC_DistributedMap_get<T>(instance, cb, excb, sentcb);
01301 }
01302
01303 template<class T, typename CT>
01304 class Callback_DistributedMap_get : public Callback_DistributedMap_get_Base, public ::IceInternal::TwowayCallback<T, CT>
01305 {
01306 public:
01307
01308 typedef IceUtil::Handle<T> TPtr;
01309
01310 typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
01311 typedef void (T::*Sent)(bool , const CT&);
01312 typedef void (T::*Response)(bool, const ::std::string&, const CT&);
01313
01314 Callback_DistributedMap_get(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01315 : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), response(cb)
01316 {
01317 }
01318
01319 virtual void __completed(const ::Ice::AsyncResultPtr& __result) const
01320 {
01321 ::GlobalTable::DistributedMapPrx __proxy = ::GlobalTable::DistributedMapPrx::uncheckedCast(__result->getProxy());
01322 ::std::string counts;
01323 bool __ret;
01324 try
01325 {
01326 __ret = __proxy->end_get(counts, __result);
01327 }
01328 catch(::Ice::Exception& ex)
01329 {
01330 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01331 __exception(__result, ex);
01332 #else
01333 ::IceInternal::Callback<T, CT>::__exception(__result, ex);
01334 #endif
01335 return;
01336 }
01337 if(response)
01338 {
01339 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
01340 (callback.get()->*response)(__ret, counts, CT::dynamicCast(__result->getCookie()));
01341 #else
01342 (::IceInternal::Callback<T, CT>::callback.get()->*response)(__ret, counts, CT::dynamicCast(__result->getCookie()));
01343 #endif
01344 }
01345 }
01346
01347 Response response;
01348 };
01349
01350 template<class T, typename CT> Callback_DistributedMap_getPtr
01351 newCallback_DistributedMap_get(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01352 {
01353 return new Callback_DistributedMap_get<T, CT>(instance, cb, excb, sentcb);
01354 }
01355
01356 template<class T, typename CT> Callback_DistributedMap_getPtr
01357 newCallback_DistributedMap_get(T* instance, void (T::*cb)(bool, const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01358 {
01359 return new Callback_DistributedMap_get<T, CT>(instance, cb, excb, sentcb);
01360 }
01361
01362 template<class T>
01363 class CallbackNC_DistributedMap_waitForAllClients : public Callback_DistributedMap_waitForAllClients_Base, public ::IceInternal::OnewayCallbackNC<T>
01364 {
01365 public:
01366
01367 typedef IceUtil::Handle<T> TPtr;
01368
01369 typedef void (T::*Exception)(const ::Ice::Exception&);
01370 typedef void (T::*Sent)(bool);
01371 typedef void (T::*Response)();
01372
01373 CallbackNC_DistributedMap_waitForAllClients(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01374 : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
01375 {
01376 }
01377 };
01378
01379 template<class T> Callback_DistributedMap_waitForAllClientsPtr
01380 newCallback_DistributedMap_waitForAllClients(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01381 {
01382 return new CallbackNC_DistributedMap_waitForAllClients<T>(instance, cb, excb, sentcb);
01383 }
01384
01385 template<class T> Callback_DistributedMap_waitForAllClientsPtr
01386 newCallback_DistributedMap_waitForAllClients(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01387 {
01388 return new CallbackNC_DistributedMap_waitForAllClients<T>(instance, 0, excb, sentcb);
01389 }
01390
01391 template<class T> Callback_DistributedMap_waitForAllClientsPtr
01392 newCallback_DistributedMap_waitForAllClients(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01393 {
01394 return new CallbackNC_DistributedMap_waitForAllClients<T>(instance, cb, excb, sentcb);
01395 }
01396
01397 template<class T> Callback_DistributedMap_waitForAllClientsPtr
01398 newCallback_DistributedMap_waitForAllClients(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
01399 {
01400 return new CallbackNC_DistributedMap_waitForAllClients<T>(instance, 0, excb, sentcb);
01401 }
01402
01403 template<class T, typename CT>
01404 class Callback_DistributedMap_waitForAllClients : public Callback_DistributedMap_waitForAllClients_Base, public ::IceInternal::OnewayCallback<T, CT>
01405 {
01406 public:
01407
01408 typedef IceUtil::Handle<T> TPtr;
01409
01410 typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
01411 typedef void (T::*Sent)(bool , const CT&);
01412 typedef void (T::*Response)(const CT&);
01413
01414 Callback_DistributedMap_waitForAllClients(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
01415 : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
01416 {
01417 }
01418 };
01419
01420 template<class T, typename CT> Callback_DistributedMap_waitForAllClientsPtr
01421 newCallback_DistributedMap_waitForAllClients(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01422 {
01423 return new Callback_DistributedMap_waitForAllClients<T, CT>(instance, cb, excb, sentcb);
01424 }
01425
01426 template<class T, typename CT> Callback_DistributedMap_waitForAllClientsPtr
01427 newCallback_DistributedMap_waitForAllClients(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01428 {
01429 return new Callback_DistributedMap_waitForAllClients<T, CT>(instance, 0, excb, sentcb);
01430 }
01431
01432 template<class T, typename CT> Callback_DistributedMap_waitForAllClientsPtr
01433 newCallback_DistributedMap_waitForAllClients(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01434 {
01435 return new Callback_DistributedMap_waitForAllClients<T, CT>(instance, cb, excb, sentcb);
01436 }
01437
01438 template<class T, typename CT> Callback_DistributedMap_waitForAllClientsPtr
01439 newCallback_DistributedMap_waitForAllClients(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
01440 {
01441 return new Callback_DistributedMap_waitForAllClients<T, CT>(instance, 0, excb, sentcb);
01442 }
01443
01444 }
01445
01446 #endif