::Ice::ObjectPrxPtr
IceInternal::checkedCastImpl(const ObjectPrxPtr& b, const string& f, const string& typeId, const Context& context)
{
if(b != ICE_NULLPTR)
{
ObjectPrxPtr bb = b->ice_facet(f);
try
{
if(bb->ice_isA(typeId, context))
{
return bb;
}
#ifndef NDEBUG
else
{
assert(typeId != "::Ice::Object");
}
#endif
}
catch(const FacetNotExistException&)
{
}
}
return ICE_NULLPTR;
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_context(const Context& newContext) const
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeContext(newContext));
return proxy;
}
bool
Ice::proxyIdentityAndFacetEqual(const ObjectPrxPtr& lhs, const ObjectPrxPtr& rhs)
{
if(!lhs && !rhs)
{
return true;
}
else if(!lhs && rhs)
{
return false;
}
else if(lhs && !rhs)
{
return false;
}
else
{
Identity lhsIdentity = lhs->ice_getIdentity();
Identity rhsIdentity = rhs->ice_getIdentity();
if(lhsIdentity == rhsIdentity)
{
string lhsFacet = lhs->ice_getFacet();
string rhsFacet = rhs->ice_getFacet();
if(lhsFacet == rhsFacet)
{
return true;
}
}
return false;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_encodingVersion(const ::Ice::EncodingVersion& encoding) const
{
if(encoding == _reference->getEncoding())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeEncoding(encoding));
return proxy;
}
}
void
IceInternal::ProxyFactory::proxyToStream(const ObjectPrxPtr& proxy, BasicStream* s) const
{
if(proxy)
{
s->write(proxy->__reference()->getIdentity());
proxy->__reference()->streamWrite(s);
}
else
{
Identity ident;
s->write(ident);
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_connectionCached(bool newCache) const
{
if(newCache == _reference->getCacheConnection())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeCacheConnection(newCache));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_collocationOptimized(bool b) const
{
if(b == _reference->getCollocationOptimized())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeCollocationOptimized(b));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_secure(bool b) const
{
if(b == _reference->getSecure())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeSecure(b));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_adapterId(const string& newAdapterId) const
{
if(newAdapterId == _reference->getAdapterId())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeAdapterId(newAdapterId));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_batchDatagram() const
{
if(_reference->getMode() == Reference::ModeBatchDatagram)
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeMode(Reference::ModeBatchDatagram));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_endpointSelection(EndpointSelectionType newType) const
{
if(newType == _reference->getEndpointSelection())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeEndpointSelection(newType));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_connectionId(const string& id) const
{
ReferencePtr ref = _reference->changeConnectionId(id);
if(ref == _reference)
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(ref);
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_compress(bool b) const
{
ReferencePtr ref = _reference->changeCompress(b);
if(ref == _reference)
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(ref);
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_locator(const LocatorPrxPtr& locator) const
{
ReferencePtr ref = _reference->changeLocator(locator);
if(ref == _reference)
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(ref);
return proxy;
}
}
ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrxPtr& prx) :
OutgoingAsyncBase(prx->__reference()->getInstance()),
_proxy(prx),
_mode(ICE_ENUM(OperationMode, Normal)),
_cnt(0),
_sent(false)
{
}
vector<EndpointIPtr>
IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrxPtr& /*serverProxy*/)
{
IceUtil::Mutex::Lock sync(*this);
if(_serverEndpoints.empty()) // Lazy initialization.
{
ObjectPrxPtr serverProxy = _router->getServerProxy();
if(!serverProxy)
{
throw NoEndpointException(__FILE__, __LINE__);
}
serverProxy = serverProxy->ice_router(0); // The server proxy cannot be routed.
_serverEndpoints = serverProxy->__reference()->getEndpoints();
}
return _serverEndpoints;
}
ObjectPtr
Ice::ObjectAdapterI::findByProxy(const ObjectPrxPtr& proxy) const
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
checkForDeactivation();
ReferencePtr ref = proxy->_getReference();
return findFacet(ref->getIdentity(), ref->getFacet());
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_locatorCacheTimeout(Int newTimeout) const
{
if(newTimeout < -1)
{
ostringstream s;
s << "invalid value passed to ice_locatorCacheTimeout: " << newTimeout;
throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, s.str());
}
if(newTimeout == _reference->getLocatorCacheTimeout())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeLocatorCacheTimeout(newTimeout));
return proxy;
}
}
bool
Ice::proxyIdentityEqual(const ObjectPrxPtr& lhs, const ObjectPrxPtr& rhs)
{
if(!lhs && !rhs)
{
return true;
}
else if(!lhs && rhs)
{
return false;
}
else if(lhs && !rhs)
{
return false;
}
else
{
return lhs->ice_getIdentity() == rhs->ice_getIdentity();
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_endpoints(const EndpointSeq& newEndpoints) const
{
vector<EndpointIPtr> endpoints;
for(EndpointSeq::const_iterator p = newEndpoints.begin(); p != newEndpoints.end(); ++p)
{
endpoints.push_back(ICE_DYNAMIC_CAST(EndpointI, *p));
}
if(endpoints == _reference->getEndpoints())
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(_reference->changeEndpoints(endpoints));
return proxy;
}
}
ObjectPrxPtr
ICE_OBJECT_PRX::ice_timeout(int t) const
{
if(t < 1 && t != -1)
{
ostringstream s;
s << "invalid value passed to ice_timeout: " << t;
throw IceUtil::IllegalArgumentException(__FILE__, __LINE__, s.str());
}
ReferencePtr ref = _reference->changeTimeout(t);
if(ref == _reference)
{
return CONST_POINTER_CAST_OBJECT_PRX;
}
else
{
ObjectPrxPtr proxy = __newInstance();
proxy->setup(ref);
return proxy;
}
}
PropertyDict
IceInternal::ProxyFactory::proxyToProperty(const ObjectPrxPtr& proxy, const string& prefix) const
{
if(proxy)
{
return proxy->__reference()->toProperty(prefix);
}
else
{
return PropertyDict();
}
}
string
IceInternal::ProxyFactory::proxyToString(const ObjectPrxPtr& proxy) const
{
if(proxy)
{
return proxy->__reference()->toString();
}
else
{
return "";
}
}
void
IceInternal::RouterInfo::addProxy(const ObjectPrxPtr& proxy)
{
assert(proxy); // Must not be called for null proxies.
{
IceUtil::Mutex::Lock sync(*this);
if(_identities.find(proxy->ice_getIdentity()) != _identities.end())
{
//
// Only add the proxy to the router if it's not already in our local map.
//
return;
}
}
ObjectProxySeq proxies;
proxies.push_back(proxy);
addAndEvictProxies(proxy, _router->addProxies(proxies));
}
bool
Ice::ObjectAdapterI::isLocal(const ObjectPrxPtr& proxy) const
{
//
// NOTE: it's important that isLocal() doesn't perform any blocking operations as
// it can be called for AMI invocations if the proxy has no delegate set yet.
//
ReferencePtr ref = proxy->_getReference();
if(ref->isWellKnown())
{
//
// Check the active servant map to see if the well-known
// proxy is for a local object.
//
return _servantManager->hasServant(ref->getIdentity());
}
else if(ref->isIndirect())
{
//
// Proxy is local if the reference adapter id matches this
// adapter id or replica group id.
//
return ref->getAdapterId() == _id || ref->getAdapterId() == _replicaGroupId;
}
else
{
vector<EndpointIPtr> endpoints = ref->getEndpoints();
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
checkForDeactivation();
//
// Proxies which have at least one endpoint in common with the
// endpoints used by this object adapter are considered local.
//
for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
for(vector<IncomingConnectionFactoryPtr>::const_iterator q = _incomingConnectionFactories.begin();
q != _incomingConnectionFactories.end(); ++q)
{
if((*q)->isLocal(*p))
{
return true;
}
}
for(vector<EndpointIPtr>::const_iterator r = _publishedEndpoints.begin();
r != _publishedEndpoints.end(); ++r)
{
if((*p)->equivalent(*r))
{
return true;
}
}
}
//
// Proxies which have at least one endpoint in common with the
// router's server proxy endpoints (if any), are also considered
// local.
//
if(_routerInfo && _routerInfo->getRouter() == proxy->ice_getRouter())
{
for(vector<EndpointIPtr>::const_iterator p = endpoints.begin(); p != endpoints.end(); ++p)
{
for(vector<EndpointIPtr>::const_iterator r = _routerEndpoints.begin(); r != _routerEndpoints.end(); ++r)
{
if((*p)->equivalent(*r))
{
return true;
}
}
}
}
}
return false;
}
OutgoingAsync::OutgoingAsync(const ObjectPrxPtr& prx) :
ProxyOutgoingAsyncBase(prx),
_encoding(getCompatibleEncoding(prx->__reference()->getEncoding())),
_synchronous(false)
{
}
TestIntfPrxPtr
allTests(const CommunicatorPtr& communicator)
{
const string endp = getTestEndpoint(communicator, 0);
cout << "testing stringToProxy... " << flush;
ObjectPrxPtr base = communicator->stringToProxy("asm:" + endp);
test(base);
cout << "ok" << endl;
cout << "testing checked cast... " << flush;
TestIntfPrxPtr obj = ICE_CHECKED_CAST(TestIntfPrx, base);
test(obj);
#ifdef ICE_CPP11_MAPPING
test(Ice::targetEquals(obj, base));
#else
test(obj == base);
#endif
cout << "ok" << endl;
cout << "testing ice_ids... " << flush;
try
{
ObjectPrxPtr o = communicator->stringToProxy("category/locate:" + endp);
o->ice_ids();
test(false);
}
catch(const UnknownUserException& ex)
{
test(ex.unknown == "::Test::TestIntfUserException");
}
catch(...)
{
test(false);
}
try
{
ObjectPrxPtr o = communicator->stringToProxy("category/finished:" + endp);
o->ice_ids();
test(false);
}
catch(const UnknownUserException& ex)
{
test(ex.unknown == "::Test::TestIntfUserException");
}
catch(...)
{
test(false);
}
cout << "ok" << endl;
cout << "testing servant locator..." << flush;
base = communicator->stringToProxy("category/locate:" + endp);
obj = ICE_CHECKED_CAST(TestIntfPrx, base);
try
{
ICE_CHECKED_CAST(TestIntfPrx,
communicator->stringToProxy("category/unknown:" + getTestEndpoint(communicator, 0)));
}
catch(const ObjectNotExistException&)
{
}
cout << "ok" << endl;
cout << "testing default servant locator..." << flush;
base = communicator->stringToProxy("anothercategory/locate:" + endp);
obj = ICE_CHECKED_CAST(TestIntfPrx, base);
base = communicator->stringToProxy("locate:" + endp);
obj = ICE_CHECKED_CAST(TestIntfPrx, base);
try
{
ICE_CHECKED_CAST(TestIntfPrx,
communicator->stringToProxy("anothercategory/unknown:" + getTestEndpoint(communicator, 0)));
}
catch(const ObjectNotExistException&)
{
}
try
{
ICE_CHECKED_CAST(TestIntfPrx, communicator->stringToProxy("unknown:" + endp));
}
catch(const Ice::ObjectNotExistException&)
{
}
cout << "ok" << endl;
cout << "testing locate exceptions... " << flush;
base = communicator->stringToProxy("category/locate:" + endp);
obj = ICE_CHECKED_CAST(TestIntfPrx, base);
testExceptions(obj);
cout << "ok" << endl;
cout << "testing finished exceptions... " << flush;
base = communicator->stringToProxy("category/finished:" + endp);
obj = ICE_CHECKED_CAST(TestIntfPrx, base);
testExceptions(obj);
//
// Only call these for category/finished.
//
try
{
obj->asyncResponse();
}
catch(const TestIntfUserException&)
{
test(false);
}
catch(const TestImpossibleException&)
{
//
// Called by finished().
//
}
try
{
obj->asyncException();
}
catch(const TestIntfUserException&)
{
test(false);
}
catch(const TestImpossibleException&)
{
//
// Called by finished().
//
}
cout << "ok" << endl;
cout << "testing servant locator removal... " << flush;
base = communicator->stringToProxy("test/activation:" + endp);
TestActivationPrxPtr activation = ICE_CHECKED_CAST(TestActivationPrx, base);
activation->activateServantLocator(false);
try
{
obj->ice_ping();
test(false);
}
catch(const Ice::ObjectNotExistException&)
{
cout << "ok" << endl;
}
cout << "testing servant locator addition... " << flush;
activation->activateServantLocator(true);
try
{
obj->ice_ping();
cout << "ok" << endl;
}
catch(...)
{
test(false);
}
return obj;
}
