void CAIAwarenessToPlayerHelper::Update( float frameTime )
{
m_timeToRecalculateAwareness -= frameTime;
if (m_timeToRecalculateAwareness<=0)
{
RecalculateAwareness();
m_timeToRecalculateAwareness = TIME_BETWEEN_AWARENESS_RECALCULATIONS;
}
// Animate towards the actual awareness value
float& animated = m_animatedAwarenessThatStrivesTowardsActualAwareness;
float& actual = m_actualAwareness;
const float increaseSpeed = 100.0f;
const float decreaseSpeed = 10.0f;
if (actual > animated)
{
animated = std::min(animated + increaseSpeed * frameTime, actual);
}
else if (actual < animated)
{
animated = std::min(75.0f, std::max(animated - decreaseSpeed * frameTime, actual));
}
int newIntAwareness = int_ceil(m_animatedAwarenessThatStrivesTowardsActualAwareness);
if (newIntAwareness != m_intCurrentAwareness)
{
m_intCurrentAwareness = newIntAwareness;
NotifyListeners();
}
}
void
MediaSource::SetReadyState(MediaSourceReadyState aState)
{
MOZ_ASSERT(aState != mReadyState);
MonitorAutoLock mon(mMonitor);
NotifyListeners();
if ((mReadyState == MediaSourceReadyState::Closed ||
mReadyState == MediaSourceReadyState::Ended) &&
aState == MediaSourceReadyState::Open) {
mReadyState = aState;
QueueAsyncSimpleEvent("sourceopen");
return;
}
if (mReadyState == MediaSourceReadyState::Open &&
aState == MediaSourceReadyState::Ended) {
mReadyState = aState;
QueueAsyncSimpleEvent("sourceended");
return;
}
if ((mReadyState == MediaSourceReadyState::Open ||
mReadyState == MediaSourceReadyState::Ended) &&
aState == MediaSourceReadyState::Closed) {
mReadyState = aState;
QueueAsyncSimpleEvent("sourceclose");
return;
}
NS_WARNING("Invalid MediaSource readyState transition");
}
virtual int Send(const std::string msg) {
NotifyListeners(Event::RECEIVE_DATA, nullptr,
"<U><M>u54</M><L><A></A><A><![CDATA[lobby]]></A><A>1</A><A>0</A><A><![CDATA[_MAX_CLIENTS|-1]]></A><A>14</A><A></A><A>0</A>"
"<A><![CDATA[_ROLES|0|68|_CT|1401978171488|36]]></A><A><![CDATA[]]></A></L></U>",
UPC::Status::SUCCESS);
return 0;
}
bool CDialogSession::Stop()
{
bool bStopped = DoStop();
if (bStopped)
NotifyListeners(eDSE_UserStopped);
return bStopped;
}
void
MediaSource::AppendData(const uint8_t* aData, uint32_t aLength, ErrorResult& aRv)
{
MonitorAutoLock mon(mMonitor);
LOG(PR_LOG_DEBUG, ("%p Append(ArrayBuffer=%u) mData=%u", this, aLength, mData.Length()));
mData.AppendElements(aData, aLength);
NotifyListeners();
}
/// Verändert Ein/Auslagerungseinstellungen (visuell)
void nobBaseWarehouse::SetInventorySettingVisual(const bool isJob, const unsigned char type, InventorySetting state)
{
state.MakeValid();
if(isJob)
inventorySettingsVisual.figures[type] = state;
else
inventorySettingsVisual.wares[type] = state;
NotifyListeners(1);
}
bool CEntityClassRegistry::UnregisterEntityClass( IEntityClass *pClass )
{
assert( pClass != NULL );
if (FindClass(pClass->GetName()))
{
m_mapClassName.erase(pClass->GetName());
NotifyListeners(ECRE_CLASS_UNREGISTERED, pClass);
pClass->Release();
return true;
}
return false;
}
bool ActionManager::Do (iAction* action)
{
csRef<iAction> undoAction (action->Do ());
if (!undoAction.IsValid ())
return false;
redoStack.Empty ();
undoStack.Push (undoAction);
NotifyListeners (action);
return true;
}
bool ActionManager::Redo ()
{
if (redoStack.IsEmpty ())
return false;
csRef<iAction> action (redoStack.Pop ());
csRef<iAction> undoAction (action->Do ());
if (undoAction.IsValid ())
undoStack.Push (undoAction);
NotifyListeners (action);
return true;
}
void UPAConsumer::RecoverConnection()
{
// notify listeners that we are not connected
mama_log (MAMA_LOG_LEVEL_FINE, "Recovering Connection");
NotifyListeners(false, "Recovering Connection");
// reset the channel
if ((rsslConsumerChannel_ != NULL) && (rsslConsumerChannel_->socketId != -1))
{
RemoveChannel(rsslConsumerChannel_);
rsslConsumerChannel_ = NULL;
}
// and flag a reconnect
shouldRecoverConnection_ = RSSL_TRUE;
}
int FindDentsAlgorithm::CountDents()
{
int nParts = 50;
for(int i = 0; i < nParts; i++)
{
// do complex operation...
for(int j = 0; j < 1000000; j++)
{
sqrt(100.0 * j);
}
// notify listeners
NotifyListeners(i, nParts);
}
// we always find 42 dents.
return 42;
}
void WatchDog::TestPath(const CStdString &strPath)
{
#ifdef WATCHDOG_DONT_TEST_PATH
return;
#else
CFileItem item;
item.m_strPath = strPath;
bool bAvailable = false;
bool bHasInfo = false;
if (item.IsInternetStream() || item.IsPlugin() || item.IsScript() || item.IsApp())
{
bAvailable = IsConnectedToInternet();
bHasInfo = true;
}
else if (!CUtil::IsSmb(strPath) || !g_application.IsPlaying())
{
DIRECTORY::IDirectory* pDir = DIRECTORY::CFactoryDirectory::Create(strPath);
if (pDir)
{
bAvailable = pDir->Exists(strPath);
bHasInfo = true;
delete pDir;
}
}
// if (item.IsSmb() || item.IsHD())
// {
// CLog::Log(LOGDEBUG,"WatchDog::TestPath - [share=%s][available=%d][hasInfo=%d] (testpath)",strPath.c_str(), bAvailable, bHasInfo);
// }
if (bHasInfo)
{
CSingleLock lock(m_lock);
// If there was a change in a status, notify listeners
if ( (bAvailable && m_mapPaths[strPath] != WD_AVAILABLE) || (!bAvailable && m_mapPaths[strPath] != WD_UNAVAILABLE) )
NotifyListeners(strPath, bAvailable);
m_mapPaths[strPath] = bAvailable?WD_AVAILABLE:WD_UNAVAILABLE;
//CLog::Log(LOGDEBUG,"WatchDog::TestPath - For [share=%s] set [available=%d] (testpath)",strPath.c_str(), m_mapPaths[strPath]);
}
#endif
}
bool CEntityClassRegistry::RegisterEntityClass( IEntityClass *pClass )
{
assert( pClass != NULL );
bool newClass = false;
if ((pClass->GetFlags() & ECLF_MODIFY_EXISTING) == 0)
{
IEntityClass *pOldClass = FindClass(pClass->GetName());
if (pOldClass)
{
EntityWarning( "CEntityClassRegistry::RegisterEntityClass failed, class with name %s already registered",
pOldClass->GetName() );
return false;
}
newClass = true;
}
m_mapClassName[pClass->GetName()] = pClass;
NotifyListeners(newClass ? ECRE_CLASS_REGISTERED : ECRE_CLASS_MODIFIED, pClass);
return true;
}
/// Verändert Ein/Auslagerungseinstellungen (real)
void nobBaseWarehouse::SetInventorySetting(const bool isJob, const unsigned char type, InventorySetting state)
{
state.MakeValid();
InventorySetting oldState;
if(isJob)
{
oldState = inventorySettings.figures[type];
inventorySettings.figures[type] = state;
}
else
{
oldState = inventorySettings.wares[type];
inventorySettings.wares[type] = state;
}
/// Bei anderen Spielern als dem lokalen, der das in Auftrag gegeben hat, müssen die visuellen ebenfalls
/// geändert werden oder auch bei Replays
if(GAMECLIENT.IsReplayModeOn() || GAMECLIENT.GetPlayerID() != player)
SetInventorySettingVisual(isJob, type, state);
if(oldState.IsSet(EInventorySetting::STOP) && !state.IsSet(EInventorySetting::STOP))
{
// Evtl gabs verlorene Waren, die jetzt in das HQ wieder reinkönnen
gwg->GetPlayer(player).FindClientForLostWares();
} // No else here!
if(!oldState.IsSet(EInventorySetting::SEND) && state.IsSet(EInventorySetting::SEND))
{
// Sind Waren vorhanden, die ausgelagert werden müssen und ist noch kein Auslagerungsevent vorhanden --> neues anmelden
if(!empty_event && (isJob ? inventory[Job(type)] : inventory[GoodType(type)]))
empty_event = em->AddEvent(this, empty_INTERVAL, 3);
}else if(!oldState.IsSet(EInventorySetting::COLLECT) && state.IsSet(EInventorySetting::COLLECT))
{
// Sollen Waren eingelagert werden? Dann müssen wir neue bestellen
if(!store_event)
store_event = em->AddEvent(this, STORE_INTERVAL, 4);
}
NotifyListeners(1);
}
bool KDBGSearch::Search(PBYTE pBuffer, DWORD dwSize, DWORD_PTR dwAddress, std::vector<Artefact> &artefacts)
{
// if all relevant addresses have already been found, just return
if(m_addressesFound)
{
return m_addressesFound;
}
// read 4 bytes at a time, starting at the beginning of the buffer
for(DWORD i = 0; i < dwSize; i += 4)
{
// KDBG tag
DWORD dwKDBGTag = *((PDWORD)(pBuffer + i));
// check if KDBG tag is encountered
if(dwKDBGTag == m_KDBGTag)
{
DWORD_PTR dwPsActiveProcessHeadAddress = *((PDWORD_PTR)(pBuffer + i + m_offsetMap["PsActiveProcessHead"]));
#ifdef _WIN32
// do some error checking
if(dwPsActiveProcessHeadAddress <= 0x80000000)
{
continue;
}
else
#endif // _WIN32
{
m_addressesFound = true;
NotifyListeners(dwPsActiveProcessHeadAddress);
break;
}
}
}
return m_addressesFound;
}
virtual int Send(const std::string msg){
NotifyListeners(Event::RECEIVE_DATA, nullptr, "<U><M>u63</M><L></L></U>", UPC::Status::SUCCESS);
return 0;
}
virtual int Send(const std::string msg){
NotifyListeners(Event::RECEIVE_DATA, nullptr, "<U><M>u66</M><L><A><![CDATA[Union Server 2.1.0 (build 590)]]></A><A>1505998205ea8eab26-e9d5-4b3e-8d71-be6527b885b6</A><A>1.10.3</A><A>true</A><A></A><A>0</A></L></U>", UPC::Status::SUCCESS);
return 0;
}
virtual int Disconnect(){
NotifyListeners(Event::DISCONNECTED, nullptr, "", UPC::Status::SUCCESS);
return 0;
}
virtual int Connect(){
NotifyListeners(Event::BEGIN_CONNECT, nullptr, "", UPC::Status::SUCCESS);
NotifyListeners(Event::CONNECTED, nullptr, "", UPC::Status::SUCCESS);
return 0;
}
virtual int Connect(){
NotifyListeners(Event::CONNECT_FAILURE, nullptr, "[Killed]", UPC::Status::CLIENT_KILL_CONNECT);
return 0;
}
virtual int Connect(){
NotifyListeners(Event::CONNECT_FAILURE, nullptr, "[Lost]", UPC::Status::SESSION_NOT_FOUND);
return 0;
}
virtual int Connect(){
NotifyListeners(Event::CONNECT_FAILURE, nullptr, "[Version]", UPC::Status::PROTOCOL_INCOMPATIBLE);
return 0;
}
virtual int Connect(){
NotifyListeners(Event::CONNECT_FAILURE, nullptr, "[Because]", UPC::Status::CONNECT_REFUSED);
return 0;
}
virtual int Connect(){
NotifyListeners(Event::CONNECT_FAILURE, nullptr, "[Low level IO Error]", -1);
return 0;
}
DataChangedObservable::~DataChangedObservable()
{
NotifyListeners(0);
}
void CAICounter_Alertness::UpdateCounters()
{
if (!gEnv->pGame)
return;
const IActor* pLocalPlayer = gEnv->pGame->GetIGameFramework()->GetClientActor();
const IAIObject* pAILocalPlayer = pLocalPlayer ? pLocalPlayer->GetEntity()->GetAI() : NULL;
if (!pAILocalPlayer)
return;
m_bJustUpdated = true;
if (!m_bFactionVectorsAreValid)
{
m_alertnessFaction.clear();
m_alertnessFaction.resize( gEnv->pAISystem->GetFactionMap().GetFactionCount(), 0 );
m_tempAlertnessFaction.resize( gEnv->pAISystem->GetFactionMap().GetFactionCount(), 0 );
m_bFactionVectorsAreValid = true;
}
for (std::vector<int>::iterator iter = m_tempAlertnessFaction.begin(); iter!=m_tempAlertnessFaction.end(); ++iter)
(*iter)=0;
int alertnessGlobal = 0;
int alertnessFriends = 0;
int alertnessEnemies = 0;
IActorIteratorPtr actorIt = gEnv->pGame->GetIGameFramework()->GetIActorSystem()->CreateActorIterator();
while (IActor *pActor=actorIt->Next())
{
if (pActor && pActor!=pLocalPlayer)
{
const IAIObject* pAIObject = pActor->GetEntity()->GetAI();
if (pAIObject)
{
const IAIActor* pAIActor = pAIObject->CastToIAIActor();
CRY_ASSERT(pAIActor);
if (pAIActor && pAIActor->IsActive())
{
int alertness = pAIActor->GetProxy()->GetAlertnessState();
alertnessGlobal = max( alertnessGlobal, alertness );
uint32 faction = pAIObject->GetFactionID();
m_tempAlertnessFaction[ faction ] = max( m_tempAlertnessFaction[ faction ], alertness );
bool enemy = pAIObject->IsHostile( pAILocalPlayer );
if (enemy)
alertnessEnemies = max( alertnessEnemies, alertness );
else
alertnessFriends = max( alertnessFriends, alertness );
}
}
}
}
bool hasChanged = false;
if (m_alertnessGlobal!=alertnessGlobal || m_alertnessEnemies!=alertnessEnemies || m_alertnessFriends!=alertnessFriends)
{
hasChanged = true;
}
else
{
std::vector<int>::iterator iterTemp = m_tempAlertnessFaction.begin();
std::vector<int>::iterator iter = m_alertnessFaction.begin();
for (; iterTemp!=m_tempAlertnessFaction.end(); ++iterTemp, ++iter)
{
int valTemp = *iterTemp;
int val = *iter;
if (valTemp!=val)
{
hasChanged = true;
break;
}
}
}
if (hasChanged || m_bNewListeners)
{
m_alertnessGlobal = alertnessGlobal;
m_alertnessEnemies = alertnessEnemies;
m_alertnessFriends = alertnessFriends;
m_alertnessFaction.swap( m_tempAlertnessFaction );
NotifyListeners();
m_bNewListeners = false;
}
}
void
AbstractConnector::NotifyCheckConnectFailure(const CnxRef cr, const std::string msg, const int status)
{
NotifyListeners(Event::CONNECT_FAILURE, cr, msg, status);
OnConnectFailure(cr, status);
}
virtual int Connect(){
NotifyListeners(Event::CONNECT_FAILURE, nullptr, "[Got terminated]", UPC::Status::SESSION_TERMINATED);
return 0;
}
// Reset timer values
void CMMTimer::Reset()
{
m_Milliseconds = m_Count = 0;
NotifyListeners();
}
void UPAConsumer::Run()
{
RsslError error;
struct timeval time_interval;
RsslRet retval = 0;
fd_set useRead;
fd_set useExcept;
fd_set useWrt;
// get hold of the statistics logger
statsLogger_ = StatisticsLogger::GetStatisticsLogger();
// todo might want to make these configurable
#ifdef _WIN32
int rcvBfrSize = 65535;
int sendBfrSize = 65535;
#endif
int selRet;
FD_ZERO(&readfds_);
FD_ZERO(&exceptfds_);
FD_ZERO(&wrtfds_);
// The outer thread loop attempts to make / remake a connection to the rssl server
//
// Inner loop dispatches requests from the mama queue and reads the socket for incoming responses
while (runThread_)
{
// attempt to make connection
while(shouldRecoverConnection_ && runThread_)
{
login_->UPAChannel(0);
sourceDirectory_->UPAChannel(0);
upaDictionary_->UPAChannel(0);
// connect to server
t42log_info("Attempting to connect to server %s:%s...\n", connectionConfig_.Host().c_str(), connectionConfig_.Port().c_str());
if ((rsslConsumerChannel_ = ConnectToRsslServer(connectionConfig_.Host(), connectionConfig_.Port(), interfaceName_, connType_, &error)) == NULL)
{
t42log_error("Unable to connect to RSSL server: <%s>\n",error.text);
}
else
{
if (rsslConsumerChannel_)
{
// connected - set up socket fds
RsslSocket s = rsslConsumerChannel_->socketId;
FD_SET(rsslConsumerChannel_->socketId, &readfds_);
FD_SET(rsslConsumerChannel_->socketId, &wrtfds_);
FD_SET(rsslConsumerChannel_->socketId, &exceptfds_);
}
}
if (rsslConsumerChannel_ != NULL && rsslConsumerChannel_->state == RSSL_CH_STATE_ACTIVE)
shouldRecoverConnection_ = RSSL_FALSE;
//Wait for channel to become active.
while (rsslConsumerChannel_ != NULL && rsslConsumerChannel_->state != RSSL_CH_STATE_ACTIVE && runThread_)
{
useRead = readfds_;
useWrt = wrtfds_;
useExcept = exceptfds_;
/* Set a timeout value if the provider accepts the connection, but does not initialize it */
time_interval.tv_sec = 60;
time_interval.tv_usec = 0;
selRet = select(FD_SETSIZE, &useRead, &useWrt, &useExcept, &time_interval);
// select has timed out, close the channel and attempt to reconnect
if (selRet == 0)
{
t42log_warn("Channel initialization has timed out, attempting to reconnect...\n");
if (rsslConsumerChannel_)
{
FD_CLR(rsslConsumerChannel_->socketId, &readfds_);
FD_CLR(rsslConsumerChannel_->socketId, &exceptfds_);
if (FD_ISSET(rsslConsumerChannel_->socketId, &wrtfds_))
FD_CLR(rsslConsumerChannel_->socketId, &wrtfds_);
}
RecoverConnection();
}
else
// Received a response from the provider.
if (rsslConsumerChannel_ && selRet > 0 && (FD_ISSET(rsslConsumerChannel_->socketId, &useRead) || FD_ISSET(rsslConsumerChannel_->socketId, &useWrt) || FD_ISSET(rsslConsumerChannel_->socketId, &useExcept)))
{
if (rsslConsumerChannel_->state == RSSL_CH_STATE_INITIALIZING)
{
RsslInProgInfo inProg = RSSL_INIT_IN_PROG_INFO;
FD_CLR(rsslConsumerChannel_->socketId,&wrtfds_);
if ((retval = rsslInitChannel(rsslConsumerChannel_, &inProg, &error)) < RSSL_RET_SUCCESS)
{
// channel init failed, try again
t42log_warn("channelInactive fd=%d <%s>\n",
rsslConsumerChannel_->socketId,error.text);
RecoverConnection();
break;
}
else
{
switch ((int)retval)
{
case RSSL_RET_CHAN_INIT_IN_PROGRESS:
if (inProg.flags & RSSL_IP_FD_CHANGE)
{
t42log_info("Channel In Progress - New FD: %d Old FD: %d\n",rsslConsumerChannel_->socketId, inProg.oldSocket );
FD_CLR(inProg.oldSocket,&readfds_);
FD_CLR(inProg.oldSocket,&exceptfds_);
FD_SET(rsslConsumerChannel_->socketId,&readfds_);
FD_SET(rsslConsumerChannel_->socketId,&exceptfds_);
FD_SET(rsslConsumerChannel_->socketId,&wrtfds_);
}
else
{
t42log_info("Channel %d In Progress...\n", rsslConsumerChannel_->socketId);
}
break;
case RSSL_RET_SUCCESS:
{
// connected
t42log_info("Channel %d Is Active\n" ,rsslConsumerChannel_->socketId);
shouldRecoverConnection_ = RSSL_FALSE;
RsslChannelInfo chanInfo;
// log channel info
if ((retval = rsslGetChannelInfo(rsslConsumerChannel_, &chanInfo, &error)) >= RSSL_RET_SUCCESS)
{
RsslUInt32 i;
for (i = 0; i < chanInfo.componentInfoCount; i++)
{
t42log_info("Connected to %s device.\n", chanInfo.componentInfo[i]->componentVersion.data);
}
}
login_->UPAChannel(rsslConsumerChannel_);
sourceDirectory_->UPAChannel(rsslConsumerChannel_);
upaDictionary_->UPAChannel(rsslConsumerChannel_);
mama_log (MAMA_LOG_LEVEL_FINEST, "Provider returned \"Connection Successful\"");
NotifyListeners(true, "Provider returned \"Connection Successful\"");
}
break;
default:
{
// Connection has failed
char buff[256]={0};
memset(buff,0,sizeof(buff));
sprintf(buff, "Bad return value on connection fd=%d <%s>\n", rsslConsumerChannel_->socketId,error.text);
t42log_error("%s\n", buff);
NotifyListeners(false, buff);
runThread_ = false;
}
break;
}
}
}
}
else
if (selRet < 0)
{
t42log_error("Select error.\n");
runThread_ = false;
break;
}
}
// wait a while before retry
if (shouldRecoverConnection_)
{
LogReconnection();
WaitReconnectionDelay();
}
}
// WINDOWS: change size of send/receive buffer since it's small by default
#ifdef _WIN32
if (rsslConsumerChannel_ && rsslIoctl(rsslConsumerChannel_, RSSL_SYSTEM_WRITE_BUFFERS, &sendBfrSize, &error) != RSSL_RET_SUCCESS)
{
t42log_error("rsslIoctl(): failed <%s>\n", error.text);
}
if (rsslConsumerChannel_ && rsslIoctl(rsslConsumerChannel_, RSSL_SYSTEM_READ_BUFFERS, &rcvBfrSize, &error) != RSSL_RET_SUCCESS)
{
t42log_error("rsslIoctl(): failed <%s>\n", error.text);
}
#endif
/* Initialize ping handler */
if (rsslConsumerChannel_)
InitPingHandler(rsslConsumerChannel_);
int64_t queueCount = 0;
/* this is the message processing loop */
while (runThread_)
{
// first dispatch some events off the event queue
if (!PumpQueueEvents())
{
break;
}
if ((rsslConsumerChannel_ != NULL) && (rsslConsumerChannel_->socketId != -1))
{
// if we have a connection
useRead = readfds_;
useExcept = exceptfds_;
useWrt = wrtfds_;
time_interval.tv_sec = 0;
time_interval.tv_usec = 100000;
// look at the socket state
selRet = select(FD_SETSIZE, &useRead, &useWrt, &useExcept, &time_interval);
}
else
{
// no connection, just sleep for 1s
#ifdef _WIN32
Sleep(1000);
#else
sleep(1);
#endif
continue;
}
if (!runThread_)
{
// thread is stopped
break;
}
if (selRet < 0) // no messages received, continue
{
#ifdef _WIN32
if (WSAGetLastError() == WSAEINTR)
continue;
#else
if (errno == EINTR)
{
continue;
}
#endif
}
else if (selRet > 0) // messages received
{
if ((rsslConsumerChannel_ != NULL) && (rsslConsumerChannel_->socketId != -1))
{
if ((FD_ISSET(rsslConsumerChannel_->socketId, &useRead)) ||
(FD_ISSET(rsslConsumerChannel_->socketId, &useExcept)))
{
// This will empty the read buffer and dispatch incoming events
if (ReadFromChannel(rsslConsumerChannel_) != RSSL_RET_SUCCESS)
{
// the read failed so attempt to recover if required
if(RSSL_TRUE == shouldRecoverConnection_)
{
RecoverConnection();
}
else
{
// otherwise just run out of the thread
runThread_ = false;
}
}
}
// If there's anything to be written flush the write socket
if (rsslConsumerChannel_ != NULL &&
FD_ISSET(rsslConsumerChannel_->socketId, &useWrt) &&
rsslConsumerChannel_->state == RSSL_CH_STATE_ACTIVE)
{
if ((retval = rsslFlush(rsslConsumerChannel_, &error)) < RSSL_RET_SUCCESS)
{
t42log_error("rsslFlush() failed with return code %d - <%s>\n", retval, error.text);
}
else if (retval == RSSL_RET_SUCCESS)
{
// and clear the fd
FD_CLR(rsslConsumerChannel_->socketId, &wrtfds_);
}
}
}
}
// break out of message processing loop if should recover connection
if (shouldRecoverConnection_ == RSSL_TRUE)
{
LogReconnection();
WaitReconnectionDelay();
break;
}
// check if its time to process pings
if (rsslConsumerChannel_)
{
ProcessPings(rsslConsumerChannel_);
}
}
}
// thread has stopped
RemoveChannel(rsslConsumerChannel_);
t42log_debug("Exit UPAConsumer thread\n");
}
