37 #if defined(_MSC_VER) && (_MSC_VER <= 1600)
62 class ICE_API ProxyFlushBatchAsync :
public ProxyOutgoingAsyncBase
66 ProxyFlushBatchAsync(
const Ice::ObjectPrxPtr&);
68 virtual AsyncStatus invokeRemote(
const Ice::ConnectionIPtr&,
bool,
bool);
69 virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*);
71 void invoke(
const std::string&);
82 class ICE_API ProxyGetConnection :
public ProxyOutgoingAsyncBase
86 ProxyGetConnection(
const Ice::ObjectPrxPtr&);
88 virtual AsyncStatus invokeRemote(
const Ice::ConnectionIPtr&,
bool,
bool);
89 virtual AsyncStatus invokeCollocated(CollocatedRequestHandler*);
91 virtual Ice::ConnectionPtr getConnection()
const;
93 void invoke(
const std::string&);
99 #ifdef ICE_CPP11_MAPPING // C++11 mapping
101 namespace IceInternal
105 ::std::shared_ptr<P> createProxy()
107 return ::std::shared_ptr<P>(
new P());
110 inline ::std::pair<const Ice::Byte*, const Ice::Byte*>
115 return {
nullptr,
nullptr };
119 return { seq.data(), seq.data() + seq.size() };
124 class InvokeOutgoingAsyncT :
public OutgoingAsync
128 using OutgoingAsync::OutgoingAsync;
131 invoke(
const std::string& operation,
133 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
140 stream->readEncapsulation(encaps, sz);
141 return R { ok, { encaps, encaps + sz } };
146 prepare(operation, mode, context);
147 if(inParams.first == inParams.second)
149 _os.writeEmptyEncapsulation(_encoding);
153 _os.writeEncapsulation(inParams.first,
static_cast<Ice::Int>(inParams.second - inParams.first));
155 OutgoingAsync::invoke(operation);
169 class InvokeLambdaOutgoing :
public InvokeOutgoingAsyncT<R>,
public LambdaInvoke
173 InvokeLambdaOutgoing(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy,
174 ::std::function<
void(R)> response,
175 ::std::function<
void(::std::exception_ptr)> ex,
176 ::std::function<
void(
bool)> sent) :
177 InvokeOutgoingAsyncT<R>(proxy, false), LambdaInvoke(::std::move(ex), ::std::move(sent))
181 #if ICE_CPLUSPLUS >= 201402L
183 _response = [
this, response = std::move(response)](
bool ok)
185 _response = [
this, response](
bool ok)
188 if(this->_is.b.empty())
190 response(R { ok, { 0, 0 }});
194 response(this->_read(ok, &this->_is));
201 template<
typename P,
typename R>
202 class InvokePromiseOutgoing :
public InvokeOutgoingAsyncT<R>,
public PromiseInvoke<P>
206 InvokePromiseOutgoing(
const std::shared_ptr<Ice::ObjectPrx>& proxy,
bool synchronous) :
207 InvokeOutgoingAsyncT<R>(proxy, false)
209 this->_synchronous = synchronous;
210 this->_response = [
this](
bool ok)
212 if(this->_is.b.empty())
214 this->_promise.set_value(R { ok, { 0, 0 }});
218 this->_promise.set_value(this->_read(ok, &this->_is));
223 virtual bool handleSent(
bool done,
bool)
override
227 this->_promise.set_value(R {
true, { 0, 0 }});
233 class ProxyGetConnectionLambda :
public ProxyGetConnection,
public LambdaInvoke
237 ProxyGetConnectionLambda(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy,
238 ::std::function<
void(::std::shared_ptr<Ice::Connection>)> response,
239 ::std::function<
void(::std::exception_ptr)> ex,
240 ::std::function<
void(
bool)> sent) :
241 ProxyGetConnection(proxy), LambdaInvoke(::std::move(ex), ::std::move(sent))
243 #if ICE_CPLUSPLUS >= 201402L
244 _response = [&, response = std::move(response)](bool)
246 _response = [&, response](
bool)
249 response(getConnection());
255 class ProxyGetConnectionPromise :
public ProxyGetConnection,
public PromiseInvoke<P>
259 ProxyGetConnectionPromise(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy) : ProxyGetConnection(proxy)
261 this->_response = [&](bool)
263 this->_promise.set_value(getConnection());
268 class ProxyFlushBatchLambda :
public ProxyFlushBatchAsync,
public LambdaInvoke
272 ProxyFlushBatchLambda(const ::std::shared_ptr<::Ice::ObjectPrx>& proxy,
273 ::std::function<
void(::std::exception_ptr)> ex,
274 ::std::function<
void(
bool)> sent) :
275 ProxyFlushBatchAsync(proxy), LambdaInvoke(::std::move(ex), ::std::move(sent))
281 class ProxyFlushBatchPromise :
public ProxyFlushBatchAsync,
public PromiseInvoke<P>
285 using ProxyFlushBatchAsync::ProxyFlushBatchAsync;
287 virtual bool handleSent(
bool,
bool)
override
289 this->_promise.set_value();
301 using RouterPrxPtr = ::std::shared_ptr<::Ice::RouterPrx>;
306 using LocatorPrxPtr = ::std::shared_ptr<::Ice::LocatorPrx>;
309 class LocalException;
347 return _makePromiseOutgoing<bool>(
true,
this, &ObjectPrx::_iceI_isA, typeId, context).get();
359 ::std::function<void()>
361 ::std::function<
void(
bool)> response,
362 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
363 ::std::function<
void(
bool)> sent =
nullptr,
366 return _makeLamdaOutgoing<bool>(std::move(response), std::move(ex), std::move(sent),
this,
367 &ObjectPrx::_iceI_isA, typeId, context);
376 template<
template<
typename>
class P = std::promise>
auto
378 -> decltype(std::declval<P<bool>>().get_future())
380 return _makePromiseOutgoing<bool, P>(
false,
this, &ObjectPrx::_iceI_isA, typeId, context);
385 _iceI_isA(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&,
const ::Ice::Context&);
395 _makePromiseOutgoing<void>(
true,
this, &ObjectPrx::_iceI_ping, context).get();
406 ::std::function<void()>
408 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
409 ::std::function<
void(
bool)> sent =
nullptr,
412 return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent),
this,
413 &ObjectPrx::_iceI_ping, context);
421 template<
template<
typename>
class P = std::promise>
423 -> decltype(std::declval<P<void>>().get_future())
425 return _makePromiseOutgoing<void, P>(
false,
this, &ObjectPrx::_iceI_ping, context);
430 _iceI_ping(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&,
const ::Ice::Context&);
439 ::std::vector<::std::string>
442 return _makePromiseOutgoing<::std::vector<::std::string>>(
true,
this, &ObjectPrx::_iceI_ids, context).get();
453 ::std::function<void()>
454 ice_idsAsync(::std::function<
void(::std::vector<::std::string>)> response,
455 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
456 ::std::function<
void(
bool)> sent =
nullptr,
459 return _makeLamdaOutgoing<::std::vector<::std::string>>(std::move(response), std::move(ex), std::move(sent),
460 this, &ObjectPrx::_iceI_ids, context);
468 template<
template<
typename>
class P = std::promise>
auto
470 -> decltype(std::declval<P<::std::vector<::std::string>>>().get_future())
472 return _makePromiseOutgoing<::std::vector<::std::string>, P>(
false,
this, &ObjectPrx::_iceI_ids, context);
477 _iceI_ids(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::vector<::std::string>>>&,
const ::Ice::Context&);
488 return _makePromiseOutgoing<::std::string>(
true,
this, &ObjectPrx::_iceI_id, context).get();
499 ::std::function<void()>
501 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
502 ::std::function<
void(
bool)> sent =
nullptr,
505 return _makeLamdaOutgoing<::std::string>(std::move(response), std::move(ex), std::move(sent),
this,
506 &ObjectPrx::_iceI_id, context);
514 template<
template<
typename>
class P = std::promise>
516 -> decltype(std::declval<P<::std::string>>().get_future())
518 return _makePromiseOutgoing<::std::string, P>(
false,
this, &ObjectPrx::_iceI_id, context);
523 _iceI_id(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&,
const ::Ice::Context&);
532 return ::Ice::Object::ice_staticId();
550 const ::std::vector<Byte>& inParams,
551 ::std::vector<::Ice::Byte>& outParams,
554 return ice_invoke(operation, mode, ::IceInternal::makePair(inParams), outParams, context);
565 template<
template<
typename>
class P = std::promise>
auto
568 const ::std::vector<Byte>& inParams,
570 -> decltype(std::declval<P<::Ice::Object::Ice_invokeResult>>().get_future())
572 return ice_invokeAsync<P>(operation, mode, ::IceInternal::makePair(inParams), context);
586 ::std::function<void()>
589 const ::std::vector<::Ice::Byte>& inParams,
590 ::std::function<
void(
bool, ::std::vector<::Ice::Byte>)> response,
591 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
592 ::std::function<
void(
bool)> sent =
nullptr,
595 using Outgoing = ::IceInternal::InvokeLambdaOutgoing<::Ice::Object::Ice_invokeResult>;
599 #if ICE_CPLUSPLUS >= 201402L
605 response(result.returnValue, std::move(result.outParams));
608 auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), std::move(r), std::move(ex), std::move(sent));
609 outAsync->invoke(operation, mode, ::IceInternal::makePair(inParams), context);
610 return [outAsync]() { outAsync->cancel(); };
628 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
629 ::std::vector<::Ice::Byte>& outParams,
632 using Outgoing = ::IceInternal::InvokePromiseOutgoing<
634 auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(),
true);
635 outAsync->invoke(operation, mode, inParams, context);
636 auto result = outAsync->getFuture().get();
637 outParams.swap(result.outParams);
638 return result.returnValue;
649 template<
template<
typename>
class P = std::promise>
auto
652 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
654 -> decltype(std::declval<P<::Ice::Object::Ice_invokeResult>>().get_future())
658 auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(),
false);
659 outAsync->invoke(operation, mode, inParams, context);
660 return outAsync->getFuture();
674 ::std::function<void()>
677 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
678 ::std::function<
void(
bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>)> response,
679 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
680 ::std::function<
void(
bool)> sent =
nullptr,
683 using Result = ::std::tuple<bool, ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>>;
684 using Outgoing = ::IceInternal::InvokeLambdaOutgoing<Result>;
686 ::std::function<void(Result&&)> r;
689 #if ICE_CPLUSPLUS >= 201402L
690 r = [response = std::move(response)](Result&& result)
692 r = [response](Result&& result)
695 response(::std::get<0>(result), ::std::move(::std::get<1>(result)));
698 auto outAsync = ::std::make_shared<Outgoing>(shared_from_this(), std::move(r), std::move(ex), std::move(sent));
699 outAsync->invoke(operation, mode, inParams, context);
700 return [outAsync]() { outAsync->cancel(); };
714 ::std::shared_ptr<::Ice::ObjectPrx>
ice_identity(const ::Ice::Identity&
id)
const;
740 ::std::shared_ptr<::Ice::ObjectPrx>
ice_facet(const ::std::string& facet)
const;
753 ::std::shared_ptr<::Ice::ObjectPrx>
ice_adapterId(const ::std::string&
id)
const;
819 ::std::shared_ptr<::Ice::ObjectPrx>
ice_secure(
bool b)
const;
863 ::std::shared_ptr<::Ice::ObjectPrx>
ice_router(const ::std::shared_ptr<::Ice::RouterPrx>& router)
const;
876 ::std::shared_ptr<::Ice::ObjectPrx>
ice_locator(const ::std::shared_ptr<::Ice::LocatorPrx>& locator)
const;
985 ::std::shared_ptr<::Ice::ObjectPrx>
ice_timeout(
int timeout)
const;
1014 ::std::shared_ptr<::Ice::ObjectPrx>
ice_fixed(const ::std::shared_ptr<::Ice::Connection>& connection)
const;
1027 ::std::shared_ptr<::Ice::Connection>
1030 return ice_getConnectionAsync().get();
1041 ::std::function<void()>
1043 ::std::function<
void(::std::exception_ptr)> ex =
nullptr,
1044 ::std::function<
void(
bool)> sent =
nullptr)
1046 using LambdaOutgoing = ::IceInternal::ProxyGetConnectionLambda;
1047 auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), std::move(response), std::move(ex), std::move(sent));
1048 _iceI_getConnection(outAsync);
1049 return [outAsync]() { outAsync->cancel(); };
1057 template<
template<
typename>
class P = std::promise>
auto
1060 using PromiseOutgoing = ::IceInternal::ProxyGetConnectionPromise<P<::std::shared_ptr<::Ice::Connection>>>;
1061 auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this());
1062 _iceI_getConnection(outAsync);
1063 return outAsync->getFuture();
1067 void _iceI_getConnection(const ::std::shared_ptr<::IceInternal::ProxyGetConnection>&);
1083 return ice_flushBatchRequestsAsync().get();
1092 std::function<void()>
1094 ::std::function<
void(
bool)> sent =
nullptr)
1096 using LambdaOutgoing = ::IceInternal::ProxyFlushBatchLambda;
1097 auto outAsync = ::std::make_shared<LambdaOutgoing>(shared_from_this(), std::move(ex), std::move(sent));
1098 _iceI_flushBatchRequests(outAsync);
1099 return [outAsync]() { outAsync->cancel(); };
1106 template<
template<
typename>
class P = std::promise>
auto
1109 using PromiseOutgoing = ::IceInternal::ProxyFlushBatchPromise<P<void>>;
1110 auto outAsync = ::std::make_shared<PromiseOutgoing>(shared_from_this());
1111 _iceI_flushBatchRequests(outAsync);
1112 return outAsync->getFuture();
1116 void _iceI_flushBatchRequests(const ::std::shared_ptr<::IceInternal::ProxyFlushBatchAsync>&);
1118 const ::IceInternal::ReferencePtr& _getReference()
const {
return _reference; }
1120 void _copyFrom(
const std::shared_ptr<::Ice::ObjectPrx>&);
1125 void _checkTwowayOnly(const ::std::string&)
const;
1127 ::IceInternal::RequestHandlerPtr _getRequestHandler();
1128 ::IceInternal::BatchRequestQueuePtr _getBatchRequestQueue();
1129 ::IceInternal::RequestHandlerPtr _setRequestHandler(const ::IceInternal::RequestHandlerPtr&);
1130 void _updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&);
1134 void _write(OutputStream&)
const;
1140 template<
typename R,
template<
typename>
class P = ::std::promise,
typename Obj,
typename Fn,
typename... Args>
1141 auto _makePromiseOutgoing(
bool sync, Obj obj, Fn fn, Args&&... args)
1142 -> decltype(std::declval<P<R>>().get_future())
1144 auto outAsync = ::std::make_shared<::IceInternal::PromiseOutgoing<P<R>, R>>(shared_from_this(), sync);
1145 (obj->*fn)(outAsync, std::forward<Args>(args)...);
1146 return outAsync->getFuture();
1149 template<
typename R,
typename Re,
typename E,
typename S,
typename Obj,
typename Fn,
typename... Args>
1150 ::std::function<void()> _makeLamdaOutgoing(Re r, E e, S s, Obj obj, Fn fn, Args&&... args)
1152 auto outAsync = ::std::make_shared<::IceInternal::LambdaOutgoing<R>>(shared_from_this(),
1153 std::move(r), std::move(e), std::move(s));
1154 (obj->*fn)(outAsync, std::forward<Args>(args)...);
1155 return [outAsync]() { outAsync->cancel(); };
1158 virtual ::std::shared_ptr<ObjectPrx> _newInstance()
const;
1159 ObjectPrx() =
default;
1160 friend ::std::shared_ptr<ObjectPrx> IceInternal::createProxy<ObjectPrx>();
1165 void setup(const ::IceInternal::ReferencePtr&);
1166 friend class ::IceInternal::ProxyFactory;
1168 ::IceInternal::ReferencePtr _reference;
1169 ::IceInternal::RequestHandlerPtr _requestHandler;
1170 ::IceInternal::BatchRequestQueuePtr _batchRequestQueue;
1183 return !(lhs > rhs);
1189 return !(lhs < rhs);
1195 return !(lhs == rhs);
1202 template<
typename Prx,
typename... Bases>
1295 ::std::shared_ptr<Prx>
ice_router(const ::std::shared_ptr<::Ice::RouterPrx>& router)
const
1305 ::std::shared_ptr<Prx>
ice_locator(const ::std::shared_ptr<::Ice::LocatorPrx>& locator)
const
1414 ::std::shared_ptr<Prx>
ice_fixed(const ::std::shared_ptr<::Ice::Connection>& connection)
const
1433 virtual ::std::shared_ptr<ObjectPrx> _newInstance()
const = 0;
1437 ICE_API ::std::ostream&
operator<<(::std::ostream&, const ::Ice::ObjectPrx&);
1463 const ::std::shared_ptr<ObjectPrx>& rhs);
1473 const ::std::shared_ptr<ObjectPrx>& rhs);
1483 : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
1486 bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs)
const
1499 : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
1502 bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs)
const
1515 : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
1518 bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs)
const
1531 : std::binary_function<bool, ::std::shared_ptr<ObjectPrx>&, ::std::shared_ptr<ObjectPrx>&>
1534 bool operator()(const ::std::shared_ptr<ObjectPrx>& lhs, const ::std::shared_ptr<ObjectPrx>& rhs)
const
1545 template<
typename P,
1547 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* =
nullptr,
1548 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* =
nullptr> ::std::shared_ptr<P>
1551 ::std::shared_ptr<P> r;
1554 r = ::std::dynamic_pointer_cast<P>(b);
1557 r = IceInternal::createProxy<P>();
1570 template<
typename P,
1572 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* =
nullptr,
1573 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* =
nullptr> ::std::shared_ptr<P>
1576 ::std::shared_ptr<P> r;
1579 r = IceInternal::createProxy<P>();
1580 r->_copyFrom(b->ice_facet(f));
1592 template<
typename P,
1594 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* =
nullptr,
1595 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* =
nullptr> ::std::shared_ptr<P>
1598 ::std::shared_ptr<P> r;
1601 if(b->ice_isA(P::ice_staticId(), context))
1603 r = IceInternal::createProxy<P>();
1618 template<
typename P,
1620 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, P>::value>::type* =
nullptr,
1621 typename ::std::enable_if<::std::is_base_of<::Ice::ObjectPrx, T>::value>::type* =
nullptr> ::std::shared_ptr<P>
1624 ::std::shared_ptr<P> r;
1629 ::std::shared_ptr<::Ice::ObjectPrx> bb = b->ice_facet(f);
1630 if(bb->ice_isA(P::ice_staticId(), context))
1632 r = IceInternal::createProxy<P>();
1645 #else // C++98 mapping
1655 ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Locator*);
1658 ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Router*);
1668 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::Router> RouterPrx;
1669 typedef RouterPrx RouterPrxPtr;
1670 typedef ::IceInternal::ProxyHandle< ::IceProxy::Ice::Locator> LocatorPrx;
1671 typedef LocatorPrx LocatorPrxPtr;
1673 class LocalException;
1682 class Callback_Object_ice_isA_Base :
public virtual ::IceInternal::CallbackBase { };
1683 typedef ::IceUtil::Handle< Callback_Object_ice_isA_Base> Callback_Object_ice_isAPtr;
1691 class Callback_Object_ice_ping_Base :
public virtual ::IceInternal::CallbackBase { };
1692 typedef ::IceUtil::Handle< Callback_Object_ice_ping_Base> Callback_Object_ice_pingPtr;
1700 class Callback_Object_ice_ids_Base :
public virtual ::IceInternal::CallbackBase { };
1701 typedef ::IceUtil::Handle< Callback_Object_ice_ids_Base> Callback_Object_ice_idsPtr;
1709 class Callback_Object_ice_id_Base :
public virtual ::IceInternal::CallbackBase { };
1710 typedef ::IceUtil::Handle< Callback_Object_ice_id_Base> Callback_Object_ice_idPtr;
1718 class Callback_Object_ice_invoke_Base :
public virtual ::IceInternal::CallbackBase { };
1719 typedef ::IceUtil::Handle< Callback_Object_ice_invoke_Base> Callback_Object_ice_invokePtr;
1727 class Callback_Object_ice_flushBatchRequests_Base :
public virtual ::IceInternal::CallbackBase { };
1728 typedef ::IceUtil::Handle< Callback_Object_ice_flushBatchRequests_Base> Callback_Object_ice_flushBatchRequestsPtr;
1736 class Callback_Object_ice_getConnection_Base :
public virtual ::IceInternal::CallbackBase { };
1737 typedef ::IceUtil::Handle< Callback_Object_ice_getConnection_Base> Callback_Object_ice_getConnectionPtr;
1741 namespace IceProxy {
namespace Ice
1759 ::Ice::CommunicatorPtr ice_getCommunicator()
const;
1765 ::std::string ice_toString()
const;
1776 return end_ice_isA(_iceI_begin_ice_isA(typeId, context, ::IceInternal::dummyCallback, 0,
true));
1785 ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
1788 return _iceI_begin_ice_isA(typeId, context, ::IceInternal::dummyCallback, 0);
1798 ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
1799 const ::Ice::CallbackPtr& cb,
1813 ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
1815 const ::Ice::CallbackPtr& cb,
1818 return _iceI_begin_ice_isA(typeId, context, cb, cookie);
1828 ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
1829 const ::Ice::Callback_Object_ice_isAPtr& cb,
1843 ::Ice::AsyncResultPtr begin_ice_isA(const ::std::string& typeId,
1845 const ::Ice::Callback_Object_ice_isAPtr& cb,
1848 return _iceI_begin_ice_isA(typeId, context, cb, cookie);
1857 bool end_ice_isA(const ::Ice::AsyncResultPtr& result);
1865 end_ice_ping(_iceI_begin_ice_ping(context, ::IceInternal::dummyCallback, 0,
true));
1875 return _iceI_begin_ice_ping(context, ::IceInternal::dummyCallback, 0);
1896 ::Ice::AsyncResultPtr begin_ice_ping(
const ::Ice::Context& context, const ::Ice::CallbackPtr& cb,
1899 return _iceI_begin_ice_ping(context, cb, cookie);
1908 ::Ice::AsyncResultPtr begin_ice_ping(const ::Ice::Callback_Object_ice_pingPtr& cb,
1921 ::Ice::AsyncResultPtr begin_ice_ping(
const ::Ice::Context& context, const ::Ice::Callback_Object_ice_pingPtr& cb,
1924 return _iceI_begin_ice_ping(context, cb, cookie);
1931 void end_ice_ping(const ::Ice::AsyncResultPtr& result);
1941 return end_ice_ids(_iceI_begin_ice_ids(context, ::IceInternal::dummyCallback, 0,
true));
1951 return _iceI_begin_ice_ids(context, ::IceInternal::dummyCallback, 0);
1960 ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::CallbackPtr& cb,
1974 const ::Ice::CallbackPtr& cb,
1977 return _iceI_begin_ice_ids(context, cb, cookie);
1986 ::Ice::AsyncResultPtr begin_ice_ids(const ::Ice::Callback_Object_ice_idsPtr& cb,
2000 const ::Ice::Callback_Object_ice_idsPtr& cb,
2003 return _iceI_begin_ice_ids(context, cb, cookie);
2012 ::std::vector< ::std::string> end_ice_ids(const ::Ice::AsyncResultPtr& result);
2021 return end_ice_id(_iceI_begin_ice_id(context, ::IceInternal::dummyCallback, 0,
true));
2031 return _iceI_begin_ice_id(context, ::IceInternal::dummyCallback, 0);
2040 ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::CallbackPtr& cb,
2054 const ::Ice::CallbackPtr& cb,
2057 return _iceI_begin_ice_id(context, cb, cookie);
2066 ::Ice::AsyncResultPtr begin_ice_id(const ::Ice::Callback_Object_ice_idPtr& cb,
2080 const ::Ice::Callback_Object_ice_idPtr& cb,
2083 return _iceI_begin_ice_id(context, cb, cookie);
2091 ::std::string end_ice_id(const ::Ice::AsyncResultPtr& result);
2097 static const ::std::string& ice_staticId()
2099 return ::Ice::Object::ice_staticId();
2114 bool ice_invoke(const ::std::string& operation,
2116 const ::std::vector< ::Ice::Byte>& inParams,
2117 ::std::vector< ::Ice::Byte>& outParams,
2127 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2129 const ::std::vector< ::Ice::Byte>& inParams)
2132 ::IceInternal::dummyCallback, 0);
2143 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2145 const ::std::vector< ::Ice::Byte>& inParams,
2148 return _iceI_begin_ice_invoke(operation, mode, inParams, context, ::IceInternal::dummyCallback, 0);
2160 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2162 const ::std::vector< ::Ice::Byte>& inParams,
2163 const ::Ice::CallbackPtr& cb,
2179 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2181 const ::std::vector< ::Ice::Byte>& inParams,
2183 const ::Ice::CallbackPtr& cb,
2186 return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
2198 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2200 const ::std::vector< ::Ice::Byte>& inParams,
2201 const ::Ice::Callback_Object_ice_invokePtr& cb,
2217 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2219 const ::std::vector< ::Ice::Byte>& inParams,
2221 const ::Ice::Callback_Object_ice_invokePtr& cb,
2224 return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
2236 bool end_ice_invoke(::std::vector< ::Ice::Byte>& outParams, const ::Ice::AsyncResultPtr& result);
2250 bool ice_invoke(const ::std::string& operation,
2252 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
2253 ::std::vector< ::Ice::Byte>& outParams,
2256 return end_ice_invoke(outParams, _iceI_begin_ice_invoke(operation, mode, inParams, context,
2257 ::IceInternal::dummyCallback, 0,
true));
2267 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2269 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams)
2272 ::IceInternal::dummyCallback, 0);
2284 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2286 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
2290 return _iceI_begin_ice_invoke(operation, mode, inParams, context, ::IceInternal::dummyCallback, cookie);
2302 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2304 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
2305 const ::Ice::CallbackPtr& cb,
2321 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2323 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
2325 const ::Ice::CallbackPtr& cb,
2328 return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
2340 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2342 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
2343 const ::Ice::Callback_Object_ice_invokePtr& cb,
2359 ::Ice::AsyncResultPtr begin_ice_invoke(const ::std::string& operation,
2361 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>& inParams,
2363 const ::Ice::Callback_Object_ice_invokePtr& cb,
2366 return _iceI_begin_ice_invoke(operation, mode, inParams, context, cb, cookie);
2370 bool _iceI_end_ice_invoke(::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&, const ::Ice::AsyncResultPtr&);
2403 const ::std::string& ice_getFacet()
const;
2416 ::std::string ice_getAdapterId()
const;
2442 ::Ice::Int ice_getLocatorCacheTimeout()
const;
2455 bool ice_isConnectionCached()
const;
2481 bool ice_isSecure()
const;
2503 ::Ice::ObjectPrx ice_encodingVersion(const ::Ice::EncodingVersion& version)
const;
2510 bool ice_isPreferSecure()
const;
2552 bool ice_isCollocationOptimized()
const;
2584 bool ice_isTwoway()
const;
2596 bool ice_isOneway()
const;
2608 bool ice_isBatchOneway()
const;
2620 bool ice_isDatagram()
const;
2632 bool ice_isBatchDatagram()
const;
2676 ::std::string ice_getConnectionId()
const;
2690 bool ice_isFixed()
const;
2697 ::Ice::ConnectionPtr ice_getConnection()
2699 return end_ice_getConnection(begin_ice_getConnection());
2707 ::Ice::AsyncResultPtr begin_ice_getConnection()
2709 return _iceI_begin_ice_getConnection(::IceInternal::dummyCallback, 0);
2719 ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::CallbackPtr& cb,
2722 return _iceI_begin_ice_getConnection(cb, cookie);
2732 ::Ice::AsyncResultPtr begin_ice_getConnection(const ::Ice::Callback_Object_ice_getConnectionPtr& cb,
2735 return _iceI_begin_ice_getConnection(cb, cookie);
2743 ::Ice::ConnectionPtr end_ice_getConnection(const ::Ice::AsyncResultPtr& result);
2752 ::Ice::ConnectionPtr ice_getCachedConnection()
const;
2757 void ice_flushBatchRequests()
2759 return end_ice_flushBatchRequests(begin_ice_flushBatchRequests());
2766 ::Ice::AsyncResultPtr begin_ice_flushBatchRequests()
2768 return _iceI_begin_ice_flushBatchRequests(::IceInternal::dummyCallback, 0);
2777 ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::CallbackPtr& cb,
2780 return _iceI_begin_ice_flushBatchRequests(cb, cookie);
2789 ::Ice::AsyncResultPtr begin_ice_flushBatchRequests(const ::Ice::Callback_Object_ice_flushBatchRequestsPtr& cb,
2792 return _iceI_begin_ice_flushBatchRequests(cb, cookie);
2799 void end_ice_flushBatchRequests(const ::Ice::AsyncResultPtr& result);
2802 const ::IceInternal::ReferencePtr& _getReference()
const {
return _reference; }
2806 void _copyFrom(const ::Ice::ObjectPrx&);
2811 void _checkTwowayOnly(const ::std::string&,
bool)
const;
2813 void _end(const ::Ice::AsyncResultPtr&,
const std::string&)
const;
2815 ::IceInternal::RequestHandlerPtr _getRequestHandler();
2816 ::IceInternal::BatchRequestQueuePtr _getBatchRequestQueue();
2817 ::IceInternal::RequestHandlerPtr _setRequestHandler(const ::IceInternal::RequestHandlerPtr&);
2818 void _updateRequestHandler(const ::IceInternal::RequestHandlerPtr&, const ::IceInternal::RequestHandlerPtr&);
2826 virtual Object* _newInstance()
const;
2831 ::Ice::AsyncResultPtr _iceI_begin_ice_isA(const ::std::string&,
2833 const ::IceInternal::CallbackBasePtr&,
2838 const ::IceInternal::CallbackBasePtr&,
2843 const ::IceInternal::CallbackBasePtr&,
2848 const ::IceInternal::CallbackBasePtr&,
2852 ::Ice::AsyncResultPtr _iceI_begin_ice_invoke(const ::std::string&,
2854 const ::std::vector< ::Ice::Byte>&,
2856 const ::IceInternal::CallbackBasePtr&,
2860 ::Ice::AsyncResultPtr _iceI_begin_ice_invoke(const ::std::string&,
2862 const ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
2864 const ::IceInternal::CallbackBasePtr&,
2868 ::Ice::AsyncResultPtr _iceI_begin_ice_getConnection(const ::IceInternal::CallbackBasePtr&,
2871 ::Ice::AsyncResultPtr _iceI_begin_ice_flushBatchRequests(const ::IceInternal::CallbackBasePtr&,
2874 void setup(const ::IceInternal::ReferencePtr&);
2875 friend class ::IceInternal::ProxyFactory;
2877 ::IceInternal::ReferencePtr _reference;
2878 ::IceInternal::RequestHandlerPtr _requestHandler;
2879 ::IceInternal::BatchRequestQueuePtr _batchRequestQueue;
2885 ICE_API ::std::ostream&
operator<<(::std::ostream&, const ::IceProxy::Ice::Object&);
2894 template<
typename Prx,
typename Base>
2895 class Proxy :
public virtual Base
2906 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_context(context).get());
2914 IceInternal::ProxyHandle<Prx>
ice_adapterId(const ::std::string&
id)
const
2916 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_adapterId(
id).get());
2926 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_endpoints(endpoints).get());
2936 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(timeout).get());
2946 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_connectionCached(b).get());
2956 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_endpointSelection(type).get());
2965 IceInternal::ProxyHandle<Prx>
ice_secure(
bool b)
const
2967 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_secure(b).get());
2979 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_preferSecure(b).get());
2987 IceInternal::ProxyHandle<Prx>
ice_router(const ::Ice::RouterPrx& router)
const
2989 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_router(router).get());
2997 IceInternal::ProxyHandle<Prx>
ice_locator(const ::Ice::LocatorPrx& locator)
const
2999 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_locator(locator).get());
3009 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_collocationOptimized(b).get());
3019 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_invocationTimeout(timeout).get());
3026 IceInternal::ProxyHandle<Prx>
ice_twoway()
const
3028 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_twoway().get());
3035 IceInternal::ProxyHandle<Prx>
ice_oneway()
const
3037 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_oneway().get());
3046 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_batchOneway().get());
3055 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_datagram().get());
3064 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_batchDatagram().get());
3073 IceInternal::ProxyHandle<Prx>
ice_compress(
bool b)
const
3075 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_compress(b).get());
3084 IceInternal::ProxyHandle<Prx>
ice_timeout(
int timeout)
const
3086 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_timeout(timeout).get());
3095 IceInternal::ProxyHandle<Prx>
ice_connectionId(const ::std::string&
id)
const
3097 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_connectionId(
id).get());
3106 IceInternal::ProxyHandle<Prx>
ice_fixed(const ::Ice::ConnectionPtr& connection)
const
3108 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_fixed(connection).get());
3117 IceInternal::ProxyHandle<Prx>
ice_encodingVersion(const ::Ice::EncodingVersion& version)
const
3119 return dynamic_cast<Prx*
>(::IceProxy::Ice::Object::ice_encodingVersion(version).get());
3125 virtual ::IceProxy::Ice::Object* _newInstance()
const = 0;
3168 struct ProxyIdentityLess
3170 : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
3173 bool operator()(
const ObjectPrx& lhs,
const ObjectPrx& rhs)
const
3184 struct ProxyIdentityEqual
3186 : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
3189 bool operator()(
const ObjectPrx& lhs,
const ObjectPrx& rhs)
const
3200 struct ProxyIdentityAndFacetLess
3202 : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
3205 bool operator()(
const ObjectPrx& lhs,
const ObjectPrx& rhs)
const
3216 struct ProxyIdentityAndFacetEqual
3218 : std::binary_function<bool, ObjectPrx&, ObjectPrx&>
3221 bool operator()(
const ObjectPrx& lhs,
const ObjectPrx& rhs)
const
3229 namespace IceInternal
3235 template<
typename T,
typename U>
3236 inline bool operator==(
const ProxyHandle<T>& lhs,
const ProxyHandle<U>& rhs)
3238 ::IceProxy::Ice::Object* l = lhs._upCast();
3239 ::IceProxy::Ice::Object* r = rhs._upCast();
3250 template<
typename T,
typename U>
3251 inline bool operator!=(
const ProxyHandle<T>& lhs,
const ProxyHandle<U>& rhs)
3256 template<
typename T,
typename U>
3257 inline bool operator<(
const ProxyHandle<T>& lhs,
const ProxyHandle<U>& rhs)
3259 ::IceProxy::Ice::Object* l = lhs._upCast();
3260 ::IceProxy::Ice::Object* r = rhs._upCast();
3271 template<
typename T,
typename U>
3272 inline bool operator<=(
const ProxyHandle<T>& lhs,
const ProxyHandle<U>& rhs)
3274 return lhs < rhs || lhs == rhs;
3277 template<
typename T,
typename U>
3278 inline bool operator>(
const ProxyHandle<T>& lhs,
const ProxyHandle<U>& rhs)
3280 return !(lhs < rhs || lhs == rhs);
3283 template<
typename T,
typename U>
3284 inline bool operator>=(
const ProxyHandle<T>& lhs,
const ProxyHandle<U>& rhs)
3286 return !(lhs < rhs);
3292 template<
typename P> P
3298 typedef typename P::element_type T;
3300 if(b->ice_isA(T::ice_staticId(), context))
3309 template<
typename P> P
3310 uncheckedCastImpl(const ::Ice::ObjectPrx& b)
3315 typedef typename P::element_type T;
3317 d =
dynamic_cast<T*
>(b.get());
3334 ICE_API ::Ice::ObjectPrx checkedCastImpl(const ::Ice::ObjectPrx&,
const std::string&,
const std::string&,
3342 template<> inline ::Ice::ObjectPrx
3343 checkedCastImpl< ::Ice::ObjectPrx>(const ::Ice::ObjectPrx& b,
const std::string& f,
const ::Ice::Context& context)
3345 return checkedCastImpl(b, f,
"::Ice::Object", context);
3348 template<> inline ::Ice::ObjectPrx
3349 uncheckedCastImpl< ::Ice::ObjectPrx>(const ::Ice::ObjectPrx& b,
const std::string& f)
3359 template<
typename P> P
3360 checkedCastImpl(const ::Ice::ObjectPrx& b,
const std::string& f,
const ::Ice::Context& context)
3364 typedef typename P::element_type T;
3375 template<
typename P> P
3376 uncheckedCastImpl(const ::Ice::ObjectPrx& b,
const std::string& f)
3381 typedef typename P::element_type T;
3404 template<
typename P,
typename Y>
inline P
3408 return ::IceInternal::checkedCastHelper<typename P::element_type>(b, tag, context);
3416 template<
typename P,
typename Y>
inline P
3420 return ::IceInternal::uncheckedCastHelper<typename P::element_type>(b, tag);
3431 template<
typename P>
inline P
3434 return ::IceInternal::checkedCastImpl<P>(b, f, context);
3443 template<
typename P>
inline P
3444 uncheckedCast(const ::Ice::ObjectPrx& b,
const std::string& f)
3446 return ::IceInternal::uncheckedCastImpl<P>(b, f);
3451 namespace IceInternal
3458 class CallbackNC :
public virtual CallbackBase
3462 typedef T callback_type;
3467 typedef void (T::*Sent)(bool);
3469 CallbackNC(
const TPtr& instance,
Exception excb, Sent sentcb) : _callback(instance), _exception(excb), _sent(sentcb)
3482 virtual void sent(const ::Ice::AsyncResultPtr& result)
const
3486 (_callback.get()->*_sent)(result->sentSynchronously());
3490 virtual bool hasSentCallback()
const
3501 (_callback.get()->*_exception)(ex);
3513 template<
class T,
typename CT>
3514 class Callback :
public virtual CallbackBase
3518 typedef T callback_type;
3519 typedef CT cookie_type;
3524 typedef void (T::*Sent)(bool,
const CT&);
3526 Callback(
const TPtr& instance,
Exception excb, Sent sentcb) : _callback(instance), _exception(excb), _sent(sentcb)
3532 if(cookie && !CT::dynamicCast(cookie))
3539 virtual void sent(const ::Ice::AsyncResultPtr& result)
const
3543 (_callback.get()->*_sent)(result->sentSynchronously(), CT::dynamicCast(result->getCookie()));
3547 virtual bool hasSentCallback()
const
3558 (_callback.get()->*_exception)(ex, CT::dynamicCast(result->getCookie()));
3574 class TwowayCallbackNC :
public CallbackNC<T>
3581 typedef void (T::*Sent)(bool);
3583 TwowayCallbackNC(
const TPtr& instance,
bool cb,
Exception excb, Sent sentcb) : CallbackNC<T>(instance, excb, sentcb)
3585 CallbackBase::checkCallback(instance, cb || excb != 0);
3589 template<
class T,
typename CT>
3590 class TwowayCallback :
public Callback<T, CT>
3597 typedef void (T::*Sent)(bool,
const CT&);
3599 TwowayCallback(
const TPtr& instance,
bool cb,
Exception excb, Sent sentcb) : Callback<T, CT>(instance, excb, sentcb)
3601 CallbackBase::checkCallback(instance, cb || excb != 0);
3609 class OnewayCallbackNC :
public CallbackNC<T>
3616 typedef void (T::*Sent)(bool);
3617 typedef void (T::*Response)();
3619 OnewayCallbackNC(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3620 CallbackNC<T>(instance, excb, sentcb), _response(cb)
3622 CallbackBase::checkCallback(instance, cb != 0 || excb != 0);
3625 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3629 result->getProxy()->_end(result, result->getOperation());
3633 CallbackNC<T>::exception(result, ex);
3638 (CallbackNC<T>::_callback.get()->*_response)();
3647 template<
class T,
typename CT>
3648 class OnewayCallback :
public Callback<T, CT>
3655 typedef void (T::*Sent)(bool,
const CT&);
3656 typedef void (T::*Response)(
const CT&);
3658 OnewayCallback(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3659 Callback<T, CT>(instance, excb, sentcb), _response(cb)
3661 CallbackBase::checkCallback(instance, cb != 0 || excb != 0);
3664 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3668 result->getProxy()->_end(result, result->getOperation());
3672 Callback<T, CT>::exception(result, ex);
3677 (Callback<T, CT>::_callback.get()->*_response)(CT::dynamicCast(result->getCookie()));
3698 class CallbackNC_Object_ice_isA :
public Callback_Object_ice_isA_Base,
public ::IceInternal::TwowayCallbackNC<T>
3705 typedef void (T::*Sent)(bool);
3706 typedef void (T::*Response)(bool);
3708 CallbackNC_Object_ice_isA(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3709 ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb)
3714 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3719 ret = result->getProxy()->end_ice_isA(result);
3723 ::IceInternal::CallbackNC<T>::exception(result, ex);
3728 (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
3744 template<
class T,
typename CT>
3745 class Callback_Object_ice_isA :
public Callback_Object_ice_isA_Base,
public ::IceInternal::TwowayCallback<T, CT>
3752 typedef void (T::*Sent)(bool,
const CT&);
3753 typedef void (T::*Response)(bool,
const CT&);
3755 Callback_Object_ice_isA(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3756 ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb)
3761 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3766 ret = result->getProxy()->end_ice_isA(result);
3770 ::IceInternal::Callback<T, CT>::exception(result, ex);
3775 (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
3776 CT::dynamicCast(result->getCookie()));
3793 class CallbackNC_Object_ice_ping :
public Callback_Object_ice_ping_Base,
public ::IceInternal::OnewayCallbackNC<T>
3800 typedef void (T::*Sent)(bool);
3801 typedef void (T::*Response)();
3803 CallbackNC_Object_ice_ping(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3804 ::IceInternal::OnewayCallbackNC<T>(instance, cb, excb, sentcb)
3815 template<
class T,
typename CT>
3816 class Callback_Object_ice_ping :
public Callback_Object_ice_ping_Base,
public ::IceInternal::OnewayCallback<T, CT>
3823 typedef void (T::*Sent)(bool,
const CT&);
3824 typedef void (T::*Response)(
const CT&);
3826 Callback_Object_ice_ping(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3827 ::IceInternal::OnewayCallback<T, CT>(instance, cb, excb, sentcb)
3839 class CallbackNC_Object_ice_ids :
public Callback_Object_ice_ids_Base,
public ::IceInternal::TwowayCallbackNC<T>
3846 typedef void (T::*Sent)(bool);
3847 typedef void (T::*Response)(const ::std::vector< ::std::string>&);
3849 CallbackNC_Object_ice_ids(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3850 ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb)
3855 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3857 ::std::vector< ::std::string> ret;
3860 ret = result->getProxy()->end_ice_ids(result);
3864 ::IceInternal::CallbackNC<T>::exception(result, ex);
3869 (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
3885 template<
class T,
typename CT>
3886 class Callback_Object_ice_ids :
public Callback_Object_ice_ids_Base,
public ::IceInternal::TwowayCallback<T, CT>
3893 typedef void (T::*Sent)(bool,
const CT&);
3894 typedef void (T::*Response)(const ::std::vector< ::std::string>&,
const CT&);
3896 Callback_Object_ice_ids(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3897 ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb)
3902 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3904 ::std::vector< ::std::string> ret;
3907 ret = result->getProxy()->end_ice_ids(result);
3911 ::IceInternal::Callback<T, CT>::exception(result, ex);
3916 (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
3917 CT::dynamicCast(result->getCookie()));
3934 class CallbackNC_Object_ice_id :
public Callback_Object_ice_id_Base,
public ::IceInternal::TwowayCallbackNC<T>
3941 typedef void (T::*Sent)(bool);
3942 typedef void (T::*Response)(const ::std::string&);
3944 CallbackNC_Object_ice_id(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3945 ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb)
3950 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
3955 ret = result->getProxy()->end_ice_id(result);
3959 ::IceInternal::CallbackNC<T>::exception(result, ex);
3964 (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
3980 template<
class T,
typename CT>
3981 class Callback_Object_ice_id :
public Callback_Object_ice_id_Base,
public ::IceInternal::TwowayCallback<T, CT>
3988 typedef void (T::*Sent)(bool,
const CT&);
3989 typedef void (T::*Response)(const ::std::string&,
const CT&);
3991 Callback_Object_ice_id(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
3992 ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb)
3997 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
4002 ret = result->getProxy()->end_ice_id(result);
4006 ::IceInternal::Callback<T, CT>::exception(result, ex);
4011 (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
4012 CT::dynamicCast(result->getCookie()));
4029 class CallbackNC_Object_ice_invoke :
public Callback_Object_ice_invoke_Base,
public ::IceInternal::TwowayCallbackNC<T>
4036 typedef void (T::*Sent)(bool);
4037 typedef void (T::*Response)(bool,
const std::vector< ::Ice::Byte>&);
4038 typedef void (T::*ResponseArray)(bool,
const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
4040 CallbackNC_Object_ice_invoke(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
4041 ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(cb), _responseArray(0)
4045 CallbackNC_Object_ice_invoke(
const TPtr& instance, ResponseArray cb,
Exception excb, Sent sentcb) :
4046 ::IceInternal::TwowayCallbackNC<T>(instance, cb != 0, excb, sentcb), _response(0), _responseArray(cb)
4051 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
4056 std::vector< ::Ice::Byte> outParams;
4059 ok = result->getProxy()->end_ice_invoke(outParams, result);
4063 ::IceInternal::CallbackNC<T>::exception(result, ex);
4066 (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ok, outParams);
4071 std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams;
4074 ok = result->getProxy()->_iceI_end_ice_invoke(outParams, result);
4078 ::IceInternal::CallbackNC<T>::exception(result, ex);
4083 (::IceInternal::CallbackNC<T>::_callback.get()->*_responseArray)(ok, outParams);
4092 ResponseArray _responseArray;
4101 template<
class T,
typename CT>
4102 class Callback_Object_ice_invoke :
public Callback_Object_ice_invoke_Base,
public ::IceInternal::TwowayCallback<T, CT>
4109 typedef void (T::*Sent)(bool,
const CT&);
4110 typedef void (T::*Response)(bool,
const std::vector< ::Ice::Byte>&,
const CT&);
4111 typedef void (T::*ResponseArray)(bool,
const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&,
const CT&);
4113 Callback_Object_ice_invoke(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
4114 ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(cb), _responseArray(0)
4118 Callback_Object_ice_invoke(
const TPtr& instance, ResponseArray cb,
Exception excb, Sent sentcb) :
4119 ::IceInternal::TwowayCallback<T, CT>(instance, cb != 0, excb, sentcb), _response(0), _responseArray(cb)
4124 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
4129 std::vector< ::Ice::Byte> outParams;
4132 ok = result->getProxy()->end_ice_invoke(outParams, result);
4136 ::IceInternal::Callback<T, CT>::exception(result, ex);
4139 (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ok,
4141 CT::dynamicCast(result->getCookie()));
4146 std::pair<const ::Ice::Byte*, const::Ice::Byte*> outParams;
4149 ok = result->getProxy()->_iceI_end_ice_invoke(outParams, result);
4153 ::IceInternal::Callback<T, CT>::exception(result, ex);
4158 (::IceInternal::Callback<T, CT>::_callback.get()->*_responseArray)(ok,
4161 result->getCookie()));
4170 ResponseArray _responseArray;
4180 class CallbackNC_Object_ice_getConnection :
public Callback_Object_ice_getConnection_Base,
4181 public ::IceInternal::CallbackNC<T>
4187 typedef void (T::*Response)(const ::Ice::ConnectionPtr&);
4189 typedef void (T::*Sent)(bool);
4191 CallbackNC_Object_ice_getConnection(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
4192 ::IceInternal::CallbackNC<T>(instance, excb, sentcb), _response(cb)
4197 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
4199 ::Ice::ConnectionPtr ret;
4202 ret = result->getProxy()->end_ice_getConnection(result);
4206 ::IceInternal::CallbackNC<T>::exception(result, ex);
4211 (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
4227 template<
class T,
typename CT>
4228 class Callback_Object_ice_getConnection :
public Callback_Object_ice_getConnection_Base,
4229 public ::IceInternal::Callback<T, CT>
4235 typedef void (T::*Response)(const ::Ice::ConnectionPtr&,
const CT&);
4237 typedef void (T::*Sent)(bool,
const CT&);
4239 Callback_Object_ice_getConnection(
const TPtr& instance, Response cb,
Exception excb, Sent sentcb) :
4240 ::IceInternal::Callback<T, CT>(instance, excb, sentcb), _response(cb)
4245 virtual void completed(const ::Ice::AsyncResultPtr& result)
const
4247 ::Ice::ConnectionPtr ret;
4250 ret = result->getProxy()->end_ice_getConnection(result);
4254 ::IceInternal::Callback<T, CT>::exception(result, ex);
4259 (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
4260 CT::dynamicCast(result->getCookie()));
4277 class CallbackNC_Object_ice_flushBatchRequests :
public Callback_Object_ice_flushBatchRequests_Base,
4278 public ::IceInternal::OnewayCallbackNC<T>
4285 typedef void (T::*Sent)(bool);
4287 CallbackNC_Object_ice_flushBatchRequests(
const TPtr& instance,
Exception excb, Sent sentcb) :
4288 ::IceInternal::OnewayCallbackNC<T>(instance, 0, excb, sentcb)
4299 template<
class T,
typename CT>
4300 class Callback_Object_ice_flushBatchRequests :
public Callback_Object_ice_flushBatchRequests_Base,
4301 public ::IceInternal::OnewayCallback<T, CT>
4308 typedef void (T::*Sent)(bool,
const CT&);
4310 Callback_Object_ice_flushBatchRequests(
const TPtr& instance,
Exception excb, Sent sentcb) :
4311 ::IceInternal::OnewayCallback<T, CT>(instance, 0, excb, sentcb)
4324 template<
class T> Callback_Object_ice_isAPtr
4326 void (T::*cb)(
bool),
4328 void (T::*sentcb)(
bool) = 0)
4330 return new CallbackNC_Object_ice_isA<T>(instance, cb, excb, sentcb);
4341 template<
class T,
typename CT> Callback_Object_ice_isAPtr
4343 void (T::*cb)(
bool,
const CT&),
4345 void (T::*sentcb)(
bool,
const CT&) = 0)
4347 return new Callback_Object_ice_isA<T, CT>(instance, cb, excb, sentcb);
4357 template<
class T> Callback_Object_ice_isAPtr
4360 void (T::*sentcb)(
bool) = 0)
4362 return new CallbackNC_Object_ice_isA<T>(instance, 0, excb, sentcb);
4372 template<
class T,
typename CT> Callback_Object_ice_isAPtr
4375 void (T::*sentcb)(
bool,
const CT&) = 0)
4377 return new Callback_Object_ice_isA<T, CT>(instance, 0, excb, sentcb);
4388 template<
class T> Callback_Object_ice_isAPtr
4389 newCallback_Object_ice_isA(T* instance,
4390 void (T::*cb)(
bool),
4392 void (T::*sentcb)(
bool) = 0)
4394 return new CallbackNC_Object_ice_isA<T>(instance, cb, excb, sentcb);
4405 template<
class T,
typename CT> Callback_Object_ice_isAPtr
4406 newCallback_Object_ice_isA(T* instance,
4407 void (T::*cb)(
bool,
const CT&),
4409 void (T::*sentcb)(
bool,
const CT&) = 0)
4411 return new Callback_Object_ice_isA<T, CT>(instance, cb, excb, sentcb);
4421 template<
class T> Callback_Object_ice_isAPtr
4422 newCallback_Object_ice_isA(T* instance,
4424 void (T::*sentcb)(
bool) = 0)
4426 return new CallbackNC_Object_ice_isA<T>(instance, 0, excb, sentcb);
4436 template<
class T,
typename CT> Callback_Object_ice_isAPtr
4437 newCallback_Object_ice_isA(T* instance,
4439 void (T::*sentcb)(
bool,
const CT&) = 0)
4441 return new Callback_Object_ice_isA<T, CT>(instance, 0, excb, sentcb);
4452 template<
class T> Callback_Object_ice_pingPtr
4456 void (T::*sentcb)(
bool) = 0)
4458 return new CallbackNC_Object_ice_ping<T>(instance, cb, excb, sentcb);
4469 template<
class T,
typename CT> Callback_Object_ice_pingPtr
4471 void (T::*cb)(
const CT&),
4473 void (T::*sentcb)(
bool,
const CT&) = 0)
4475 return new Callback_Object_ice_ping<T, CT>(instance, cb, excb, sentcb);
4485 template<
class T> Callback_Object_ice_pingPtr
4488 void (T::*sentcb)(
bool) = 0)
4490 return new CallbackNC_Object_ice_ping<T>(instance, 0, excb, sentcb);
4500 template<
class T,
typename CT> Callback_Object_ice_pingPtr
4503 void (T::*sentcb)(
bool,
const CT&) = 0)
4505 return new Callback_Object_ice_ping<T, CT>(instance, 0, excb, sentcb);
4516 template<
class T> Callback_Object_ice_pingPtr
4517 newCallback_Object_ice_ping(T* instance,
4520 void (T::*sentcb)(
bool) = 0)
4522 return new CallbackNC_Object_ice_ping<T>(instance, cb, excb, sentcb);
4533 template<
class T,
typename CT> Callback_Object_ice_pingPtr
4534 newCallback_Object_ice_ping(T* instance,
4535 void (T::*cb)(
const CT&),
4537 void (T::*sentcb)(
bool,
const CT&) = 0)
4539 return new Callback_Object_ice_ping<T, CT>(instance, cb, excb, sentcb);
4549 template<
class T> Callback_Object_ice_pingPtr
4550 newCallback_Object_ice_ping(T* instance,
4552 void (T::*sentcb)(
bool) = 0)
4554 return new CallbackNC_Object_ice_ping<T>(instance, 0, excb, sentcb);
4564 template<
class T,
typename CT> Callback_Object_ice_pingPtr
4565 newCallback_Object_ice_ping(T* instance,
4567 void (T::*sentcb)(
bool,
const CT&) = 0)
4569 return new Callback_Object_ice_ping<T, CT>(instance, 0, excb, sentcb);
4580 template<
class T> Callback_Object_ice_idsPtr
4582 void (T::*cb)(const ::std::vector< ::std::string>&),
4584 void (T::*sentcb)(
bool) = 0)
4586 return new CallbackNC_Object_ice_ids<T>(instance, cb, excb, sentcb);
4597 template<
class T,
typename CT> Callback_Object_ice_idsPtr
4599 void (T::*cb)(const ::std::vector< ::std::string>&,
const CT&),
4601 void (T::*sentcb)(
bool,
const CT&) = 0)
4603 return new Callback_Object_ice_ids<T, CT>(instance, cb, excb, sentcb);
4613 template<
class T> Callback_Object_ice_idsPtr
4616 void (T::*sentcb)(
bool) = 0)
4618 return new CallbackNC_Object_ice_ids<T>(instance, 0, excb, sentcb);
4628 template<
class T,
typename CT> Callback_Object_ice_idsPtr
4631 void (T::*sentcb)(
bool,
const CT&) = 0)
4633 return new Callback_Object_ice_ids<T, CT>(instance, 0, excb, sentcb);
4644 template<
class T> Callback_Object_ice_idsPtr
4645 newCallback_Object_ice_ids(T* instance,
4646 void (T::*cb)(const ::std::vector< ::std::string>&),
4648 void (T::*sentcb)(
bool) = 0)
4650 return new CallbackNC_Object_ice_ids<T>(instance, cb, excb, sentcb);
4661 template<
class T,
typename CT> Callback_Object_ice_idsPtr
4662 newCallback_Object_ice_ids(T* instance,
4663 void (T::*cb)(const ::std::vector< ::std::string>&,
const CT&),
4665 void (T::*sentcb)(
bool,
const CT&) = 0)
4667 return new Callback_Object_ice_ids<T, CT>(instance, cb, excb, sentcb);
4677 template<
class T> Callback_Object_ice_idsPtr
4678 newCallback_Object_ice_ids(T* instance,
4680 void (T::*sentcb)(
bool) = 0)
4682 return new CallbackNC_Object_ice_ids<T>(instance, 0, excb, sentcb);
4692 template<
class T,
typename CT> Callback_Object_ice_idsPtr
4693 newCallback_Object_ice_ids(T* instance,
4695 void (T::*sentcb)(
bool,
const CT&) = 0)
4697 return new Callback_Object_ice_ids<T, CT>(instance, 0, excb, sentcb);
4708 template<
class T> Callback_Object_ice_idPtr
4710 void (T::*cb)(const ::std::string&),
4712 void (T::*sentcb)(
bool) = 0)
4714 return new CallbackNC_Object_ice_id<T>(instance, cb, excb, sentcb);
4725 template<
class T,
typename CT> Callback_Object_ice_idPtr
4727 void (T::*cb)(const ::std::string&,
const CT&),
4729 void (T::*sentcb)(
bool,
const CT&) = 0)
4731 return new Callback_Object_ice_id<T, CT>(instance, cb, excb, sentcb);
4741 template<
class T> Callback_Object_ice_idPtr
4744 void (T::*sentcb)(
bool) = 0)
4746 return new CallbackNC_Object_ice_id<T>(instance, 0, excb, sentcb);
4756 template<
class T,
typename CT> Callback_Object_ice_idPtr
4759 void (T::*sentcb)(
bool,
const CT&) = 0)
4761 return new Callback_Object_ice_id<T, CT>(instance, 0, excb, sentcb);
4772 template<
class T> Callback_Object_ice_idPtr
4773 newCallback_Object_ice_id(T* instance,
4774 void (T::*cb)(const ::std::string&),
4776 void (T::*sentcb)(
bool) = 0)
4778 return new CallbackNC_Object_ice_id<T>(instance, cb, excb, sentcb);
4789 template<
class T,
typename CT> Callback_Object_ice_idPtr
4790 newCallback_Object_ice_id(T* instance,
4791 void (T::*cb)(const ::std::string&,
const CT&),
4793 void (T::*sentcb)(
bool,
const CT&) = 0)
4795 return new Callback_Object_ice_id<T, CT>(instance, cb, excb, sentcb);
4805 template<
class T> Callback_Object_ice_idPtr
4806 newCallback_Object_ice_id(T* instance,
4808 void (T::*sentcb)(
bool) = 0)
4810 return new CallbackNC_Object_ice_id<T>(instance, 0, excb, sentcb);
4820 template<
class T,
typename CT> Callback_Object_ice_idPtr
4821 newCallback_Object_ice_id(T* instance,
4823 void (T::*sentcb)(
bool,
const CT&) = 0)
4825 return new Callback_Object_ice_id<T, CT>(instance, 0, excb, sentcb);
4836 template<
class T> Callback_Object_ice_invokePtr
4838 void (T::*cb)(
bool,
const std::vector<Ice::Byte>&),
4840 void (T::*sentcb)(
bool) = 0)
4842 return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
4853 template<
class T> Callback_Object_ice_invokePtr
4855 void (T::*cb)(
bool,
const std::pair<const Byte*, const Byte*>&),
4857 void (T::*sentcb)(
bool) = 0)
4859 return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
4870 template<
class T,
typename CT> Callback_Object_ice_invokePtr
4872 void (T::*cb)(
bool,
const std::vector<Ice::Byte>&,
const CT&),
4874 void (T::*sentcb)(
bool,
const CT&) = 0)
4876 return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
4887 template<
class T,
typename CT> Callback_Object_ice_invokePtr
4889 void (T::*cb)(
bool,
const std::pair<const Byte*, const Byte*>&,
4892 void (T::*sentcb)(
bool,
const CT&) = 0)
4894 return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
4904 template<
class T> Callback_Object_ice_invokePtr
4907 void (T::*sentcb)(
bool) = 0)
4909 return new CallbackNC_Object_ice_invoke<T>(instance, 0, excb, sentcb);
4919 template<
class T,
typename CT> Callback_Object_ice_invokePtr
4922 void (T::*sentcb)(
bool,
const CT&) = 0)
4924 return new Callback_Object_ice_invoke<T, CT>(instance, 0, excb, sentcb);
4935 template<
class T> Callback_Object_ice_invokePtr
4936 newCallback_Object_ice_invoke(T* instance,
4937 void (T::*cb)(
bool,
const std::vector<Ice::Byte>&),
4939 void (T::*sentcb)(
bool) = 0)
4941 return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
4952 template<
class T> Callback_Object_ice_invokePtr
4953 newCallback_Object_ice_invoke(T* instance,
4954 void (T::*cb)(
bool,
const std::pair<const Byte*, const Byte*>&),
4956 void (T::*sentcb)(
bool) = 0)
4958 return new CallbackNC_Object_ice_invoke<T>(instance, cb, excb, sentcb);
4969 template<
class T,
typename CT> Callback_Object_ice_invokePtr
4970 newCallback_Object_ice_invoke(T* instance,
4971 void (T::*cb)(
bool,
const std::vector<Ice::Byte>&,
const CT&),
4973 void (T::*sentcb)(
bool,
const CT&) = 0)
4975 return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
4986 template<
class T,
typename CT> Callback_Object_ice_invokePtr
4987 newCallback_Object_ice_invoke(T* instance,
4988 void (T::*cb)(
bool,
const std::pair<const Byte*, const Byte*>&,
const CT&),
4990 void (T::*sentcb)(
bool,
const CT&) = 0)
4992 return new Callback_Object_ice_invoke<T, CT>(instance, cb, excb, sentcb);
5002 template<
class T> Callback_Object_ice_invokePtr
5003 newCallback_Object_ice_invoke(T* instance,
5005 void (T::*sentcb)(
bool) = 0)
5007 return new CallbackNC_Object_ice_invoke<T>(
5008 instance,
static_cast<void (T::*)(
bool,
const std::vector<Ice::Byte>&)
>(0), excb, sentcb);
5018 template<
class T,
typename CT> Callback_Object_ice_invokePtr
5019 newCallback_Object_ice_invoke(T* instance,
5021 void (T::*sentcb)(
bool,
const CT&) = 0)
5023 return new Callback_Object_ice_invoke<T, CT>(
5024 instance,
static_cast<void (T::*)(
bool,
const std::vector<Ice::Byte>&,
const CT&)
>(0), excb, sentcb);
5034 template<
class T> Callback_Object_ice_getConnectionPtr
5036 void (T::*cb)(const ::Ice::ConnectionPtr&),
5039 return new CallbackNC_Object_ice_getConnection<T>(instance, cb, excb, 0);
5049 template<
class T,
typename CT> Callback_Object_ice_getConnectionPtr
5051 void (T::*cb)(const ::Ice::ConnectionPtr&,
const CT&),
5054 return new Callback_Object_ice_getConnection<T, CT>(instance, cb, excb, 0);
5064 template<
class T> Callback_Object_ice_getConnectionPtr
5065 newCallback_Object_ice_getConnection(T* instance,
5066 void (T::*cb)(const ::Ice::ConnectionPtr&),
5069 return new CallbackNC_Object_ice_getConnection<T>(instance, cb, excb, 0);
5079 template<
class T,
typename CT> Callback_Object_ice_getConnectionPtr
5080 newCallback_Object_ice_getConnection(T* instance,
5081 void (T::*cb)(const ::Ice::ConnectionPtr&,
const CT&),
5084 return new Callback_Object_ice_getConnection<T, CT>(instance, cb, excb, 0);
5095 template<
class T> Callback_Object_ice_flushBatchRequestsPtr
5098 void (T::*sentcb)(
bool) = 0)
5100 return new CallbackNC_Object_ice_flushBatchRequests<T>(instance, excb, sentcb);
5111 template<
class T,
typename CT> Callback_Object_ice_flushBatchRequestsPtr
5114 void (T::*sentcb)(
bool,
const CT&) = 0)
5116 return new Callback_Object_ice_flushBatchRequests<T, CT>(instance, excb, sentcb);
5127 template<
class T> Callback_Object_ice_flushBatchRequestsPtr
5128 newCallback_Object_ice_flushBatchRequests(T* instance,
5130 void (T::*sentcb)(
bool) = 0)
5132 return new CallbackNC_Object_ice_flushBatchRequests<T>(instance, excb, sentcb);
5143 template<
class T,
typename CT> Callback_Object_ice_flushBatchRequestsPtr
5144 newCallback_Object_ice_flushBatchRequests(T* instance,
5146 void (T::*sentcb)(
bool,
const CT&) = 0)
5148 return new Callback_Object_ice_flushBatchRequests<T, CT>(instance, excb, sentcb);