void
IceInternal::ProxyFactory::proxyToStream(const ObjectPrx& proxy, BasicStream* s) const
{
if(proxy)
{
s->write(proxy->__reference()->getIdentity());
proxy->__reference()->streamWrite(s);
}
else
{
Identity ident;
s->write(ident);
}
}
OutgoingAsync::OutgoingAsync(const ObjectPrx& prx,
const string& operation,
const CallbackBasePtr& delegate,
const LocalObjectPtr& cookie) :
ProxyOutgoingAsyncBase(prx, operation, delegate, cookie),
_encoding(getCompatibleEncoding(prx->__reference()->getEncoding()))
{
}
ObjectPtr
Ice::ObjectAdapterI::findByProxy(const ObjectPrx& proxy) const
{
IceUtil::Monitor<IceUtil::RecMutex>::Lock sync(*this);
checkForDeactivation();
ReferencePtr ref = proxy->__reference();
return findFacet(ref->getIdentity(), ref->getFacet());
}
ProxyOutgoingAsyncBase::ProxyOutgoingAsyncBase(const ObjectPrx& prx,
const string& operation,
const CallbackBasePtr& delegate,
const LocalObjectPtr& cookie) :
OutgoingAsyncBase(prx->ice_getCommunicator(), prx->__reference()->getInstance(), operation, delegate, cookie),
_proxy(prx),
_mode(Normal),
_cnt(0),
_sent(false)
{
}
PropertyDict
IceInternal::ProxyFactory::proxyToProperty(const ObjectPrx& proxy, const string& prefix) const
{
if(proxy)
{
return proxy->__reference()->toProperty(prefix);
}
else
{
return PropertyDict();
}
}
string
IceInternal::ProxyFactory::proxyToString(const ObjectPrx& proxy) const
{
if(proxy)
{
return proxy->__reference()->toString();
}
else
{
return "";
}
}
vector<EndpointIPtr>
IceInternal::RouterInfo::setServerEndpoints(const Ice::ObjectPrx& /*serverProxy*/)
{
IceUtil::Mutex::Lock sync(*this);
if(_serverEndpoints.empty()) // Lazy initialization.
{
ObjectPrx 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;
}
bool
Ice::ObjectAdapterI::isLocal(const ObjectPrx& 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->__reference();
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((*p)->equivalent((*q)->endpoint()))
{
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;
}
bool
Ice::ObjectAdapterI::isLocal(const ObjectPrx& proxy) const
{
ReferencePtr ref = proxy->__reference();
vector<EndpointIPtr>::const_iterator p;
vector<EndpointIPtr> endpoints;
IndirectReferencePtr ir = IndirectReferencePtr::dynamicCast(ref);
if(ir)
{
if(!ir->getAdapterId().empty())
{
//
// Proxy is local if the reference adapter id matches this
// adapter id or replica group id.
//
return ir->getAdapterId() == _id || ir->getAdapterId() == _replicaGroupId;
}
//
// Get Locator endpoint information for indirect references.
//
LocatorInfoPtr info = ir->getLocatorInfo();
if(info)
{
bool isCached;
try
{
endpoints = info->getEndpoints(ir, ir->getLocatorCacheTimeout(), isCached);
}
catch(const Ice::LocalException&)
{
return false;
}
}
else
{
return false;
}
}
else
{
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's incoming connection
// factories are considered local.
//
for(p = endpoints.begin(); p != endpoints.end(); ++p)
{
vector<IncomingConnectionFactoryPtr>::const_iterator q;
for(q = _incomingConnectionFactories.begin(); q != _incomingConnectionFactories.end(); ++q)
{
if((*q)->equivalent(*p))
{
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(p = endpoints.begin(); p != endpoints.end(); ++p)
{
if(binary_search(_routerEndpoints.begin(), _routerEndpoints.end(), *p)) // _routerEndpoints is sorted.
{
return true;
}
}
}
return false;
}
