bool beginPublish(Interface *, const std::string &publisherName_ = "")
{
const std::string &publisherName = (publisherName_ == "") ?
getInterfaceName((Interface *) NULL) :
publisherName_;
typedef typename Interface::RcfClientT RcfClientT;
RcfClientPtr rcfClientPtr( new RcfClientT( ClientStub(publisherName)));
return beginPublishNamed(publisherName, rcfClientPtr);
}
// remotely accessible
boost::int32_t SessionObjectFactoryService::CreateSessionObject(
const std::string &objectName)
{
StubFactoryPtr stubFactoryPtr( getStubFactory( objectName));
if (stubFactoryPtr.get())
{
RcfClientPtr rcfClientPtr( stubFactoryPtr->makeServerStub());
getTlsRcfSession().setDefaultStubEntryPtr(
StubEntryPtr( new StubEntry(rcfClientPtr)));
return RcfError_Ok;
}
return RcfError_ObjectFactoryNotFound;
}
// remotely accessible
boost::int32_t ObjectFactoryService::CreateObject(
const std::string &objectName,
Token &token)
{
RCF_LOG_3()(objectName);
{
Lock lock(mCleanupThresholdMutex);
if (!mLazyStarted)
{
mTaskEntries[0].start();
mLazyStarted = true;
}
}
// TODO: seems unnecessary to be triggering a sweep here
std::size_t nAvail = mTokenFactory->getAvailableTokenCount();
std::size_t nTotal = mTokenFactory->getTokenSpace().size();
float used = float(nTotal - nAvail) / float(nTotal);
if (used > mCleanupThreshold)
{
Lock lock(mCleanupThresholdMutex);
mCleanupThresholdCondition.notify_all(lock);
}
boost::int32_t ret = RcfError_Ok;
StubFactoryPtr stubFactoryPtr( getStubFactory( objectName));
if (stubFactoryPtr.get())
{
RcfClientPtr rcfClientPtr( stubFactoryPtr->makeServerStub());
StubEntryPtr stubEntryPtr( new StubEntry(rcfClientPtr));
ret = addObject(TokenMappedPtr(stubEntryPtr), token);
if (ret == RcfError_Ok)
{
getTlsRcfSession().setCachedStubEntryPtr(stubEntryPtr);
RCF_LOG_3()(objectName)(token) << "Dynamically bound object created.";
}
}
else
{
ret = RcfError_ObjectFactoryNotFound;
}
return ret;
}
