C++ Connection::GetUserData方法代码示例

// Close all connections
void ConnectionManager::Shutdown()
{
//	sml::PrintDebug("Shutting down connection manager") ;

	// Stop the thread (and wait until it has stopped)
	if (m_ListenerThread)
	{
		m_ListenerThread->Stop(true) ;

		// Remove the listener
		delete m_ListenerThread ;
		m_ListenerThread = NULL ;
	}

//	sml::PrintDebug("Listener stopped") ;

	// Stop the receiver thread (and wait until is has stopped)
	if (m_ReceiverThread)
	{
		m_ReceiverThread->Stop(true) ;

	//	sml::PrintDebug("Receiver stopped") ;

		// Remove the thread
		delete m_ReceiverThread ;
		m_ReceiverThread = NULL ;
	}

	// Serialize thread access to the connections list
	soar_thread::Lock lock(&m_ConnectionsMutex) ;

	for (ConnectionsIter iter = m_Connections.begin() ; iter != m_Connections.end() ; iter++)
	{
		Connection* pConnection = *iter ;
		pConnection->CloseConnection() ;

		// Remove any events that this connection is listening to
		KernelSML* pKernelSML = static_cast<KernelSML*>(pConnection->GetUserData());
		pKernelSML->RemoveAllListeners(pConnection) ;

		// Not clear that we can just delete connections as we might be inside a connection callback
		// when the shutdown comes.  So for safety, move connections to a closed list instead of deleting.
		// For now this will leak the connection object.  Later if we are confident we can delete this list.
		//delete pConnection ;
		m_ClosedConnections.push_back(pConnection) ;
	}

	m_Connections.clear() ;

	// Now clean up all closed connections.
	for (ConnectionsIter iter = m_ClosedConnections.begin() ; iter != m_ClosedConnections.end() ; iter++)
	{
		Connection* pConnection = *iter ;
		delete pConnection ;
	}
	m_ClosedConnections.clear() ;

//	sml::PrintDebug("Completed shutdown") ;
}

// Go through all connections and read any incoming commands from the sockets.
// The messages are sent to the callback registered with the connection when it was created (ReceivedCall currently).
// Those calls could take a long time to execute (e.g. a call to Run Soar).
// Returns true if we received at least one message.
bool ConnectionManager::ReceiveAllMessages()
{
	int index = 0 ;
	bool receivedOneMessage = false ;

	// We need to search this list of connections and call each in turn.
	// But we also want to allow the listener thread to add new connections while we're doing this.
	// (E.g. we might want to attach a debugger to a process that's already executing a "run" command inside "receiveMessages").
	// So we use this slightly cumbersome approach of looking up the connection based on an integer index.
	// The lookup is thread safe and if the connection list changes between lookups that's fine as this function
	// will return NULL once we go out of bounds.  (You could argue that we might miss calling a connection on a particular pass using this method
	// but that should be ok).
	Connection* pConnection = GetConnectionByIndex(index++) ;

	while (pConnection)
	{
		// Check to see if this connection has already been closed
		// (which includes if the other side has dropped its half of the socket)
		if (!pConnection->IsClosed())
		{
			receivedOneMessage = pConnection->ReceiveMessages(true) || receivedOneMessage ;
		}
		else
		{
			// If the connection has closed, delete it from the list of active connections
			RemoveConnection(pConnection) ;
			
			// Remove any events that this connection is listening to
			KernelSML* pKernelSML = static_cast<KernelSML*>(pConnection->GetUserData());
			pKernelSML->RemoveAllListeners(pConnection) ;

			// Not clear that we can just delete connections as we might be inside a connection callback
			// when the shutdown comes.  So for safety, move connections to a closed list instead of deleting.
			// For now this will leak the connection object.  Later if we are confident we can delete this list.
			//delete pConnection ;
			m_ClosedConnections.push_back(pConnection) ;

			// Since we just removed this connection we should look up the same index value again
			// so we don't skip any.  This isn't really that important.
			index-- ;
		}

		// Get the next connection (will return NULL once we reach the end of the list)
		pConnection = GetConnectionByIndex(index++) ;
	}

	// So far we don't have some sort of shutdown message the remote connections
	// can send, but if we decide to implement it this allows us to return it.
	return receivedOneMessage ;
}