NetworkThread< SocketType > Class Template Reference

#include <NetworkThread.h>

Public Member Functions
	NetworkThread ()
virtual	~NetworkThread ()
void	Stop ()
bool	Start ()
void	Wait ()
int32	GetConnectionCount () const
virtual void	AddSocket (std::shared_ptr< SocketType > sock)
tcp::socket *	GetSocketForAccept ()

Protected Member Functions
virtual void	SocketAdded (std::shared_ptr< SocketType >)
virtual void	SocketRemoved (std::shared_ptr< SocketType >)
void	AddNewSockets ()
void	Run ()
void	Update ()

Private Types
typedef std::vector < std::shared_ptr< SocketType > >	SocketContainer

Private Attributes
std::atomic< int32 >	_connections
std::atomic< bool >	_stopped
std::thread *	_thread
SocketContainer	_sockets
std::mutex	_newSocketsLock
SocketContainer	_newSockets
boost::asio::io_service	_io_service
tcp::socket	_acceptSocket
boost::asio::deadline_timer	_updateTimer

Member Typedef Documentation

template<class SocketType>

typedef std::vector<std::shared_ptr<SocketType> > NetworkThread< SocketType >::SocketContainer

private

Constructor & Destructor Documentation

template<class SocketType>

NetworkThread< SocketType >::NetworkThread ( )

inline

 : _connections(0), _stopped(false), _thread(nullptr),
 _acceptSocket(_io_service), _updateTimer(_io_service)
 {
 }

template<class SocketType>

virtual NetworkThread< SocketType >::~NetworkThread ( )

inlinevirtual

 {
 Stop();
 if (_thread)
 {
 Wait();
 delete _thread;
 }
 }

Member Function Documentation

template<class SocketType>

void NetworkThread< SocketType >::AddNewSockets ( )

inlineprotected

 {
 std::lock_guard<std::mutex> lock(_newSocketsLock);

 if (_newSockets.empty())
 return;

 for (std::shared_ptr<SocketType> sock : _newSockets)
 {
 if (!sock->IsOpen())
 {
 SocketRemoved(sock);
 --_connections;
 }
 else
 _sockets.push_back(sock);
 }

 _newSockets.clear();
 }

Here is the caller graph for this function:

template<class SocketType>

virtual void NetworkThread< SocketType >::AddSocket ( std::shared_ptr< SocketType >  sock )

inlinevirtual

 {
 std::lock_guard<std::mutex> lock(_newSocketsLock);

 ++_connections;
 _newSockets.push_back(sock);
 SocketAdded(sock);
 }

template<class SocketType>

int32 NetworkThread< SocketType >::GetConnectionCount ( ) const

inline

 {
 return _connections;
 }

template<class SocketType>

tcp::socket* NetworkThread< SocketType >::GetSocketForAccept ( )

inline

{ return &_acceptSocket; }

template<class SocketType>

void NetworkThread< SocketType >::Run ( )

inlineprotected

 {
 TC_LOG_DEBUG("misc", "Network Thread Starting");

 _updateTimer.expires_from_now(boost::posix_time::milliseconds(10));
 _updateTimer.async_wait(std::bind(&NetworkThread<SocketType>::Update, this));
 _io_service.run();

 TC_LOG_DEBUG("misc", "Network Thread exits");
 _newSockets.clear();
 _sockets.clear();
 }

Here is the caller graph for this function:

template<class SocketType>

virtual void NetworkThread< SocketType >::SocketAdded ( std::shared_ptr< SocketType >  )

inlineprotectedvirtual

Reimplemented in WorldSocketThread.

{ }

Here is the caller graph for this function:

template<class SocketType>

virtual void NetworkThread< SocketType >::SocketRemoved ( std::shared_ptr< SocketType >  )

inlineprotectedvirtual

Reimplemented in WorldSocketThread.

{ }

Here is the caller graph for this function:

template<class SocketType>

bool NetworkThread< SocketType >::Start ( )

inline

 {
 if (_thread)
 return false;

 _thread = new std::thread(&NetworkThread::Run, this);
 return true;
 }

template<class SocketType>

void NetworkThread< SocketType >::Stop ( )

inline

 {
 _stopped = true;
 _io_service.stop();
 }

Here is the caller graph for this function:

template<class SocketType>

void NetworkThread< SocketType >::Update ( )

inlineprotected

 {
 if (_stopped)
 return;

 _updateTimer.expires_from_now(boost::posix_time::milliseconds(10));
 _updateTimer.async_wait(std::bind(&NetworkThread<SocketType>::Update, this));

 AddNewSockets();

 _sockets.erase(std::remove_if(_sockets.begin(), _sockets.end(), [this](std::shared_ptr<SocketType> sock)
 {
 if (!sock->Update())
 {
 if (sock->IsOpen())
 sock->CloseSocket();

 this->SocketRemoved(sock);

 --this->_connections;
 return true;
 }

 return false;
 }), _sockets.end());
 }

template<class SocketType>

void NetworkThread< SocketType >::Wait ( )

inline

 {
 ASSERT(_thread);

 _thread->join();
 delete _thread;
 _thread = nullptr;
 }

Here is the caller graph for this function:

Member Data Documentation

template<class SocketType>

tcp::socket NetworkThread< SocketType >::_acceptSocket

private

template<class SocketType>

std::atomic<int32> NetworkThread< SocketType >::_connections

private

template<class SocketType>

boost::asio::io_service NetworkThread< SocketType >::_io_service

private

template<class SocketType>

SocketContainer NetworkThread< SocketType >::_newSockets

private

template<class SocketType>

std::mutex NetworkThread< SocketType >::_newSocketsLock

private

template<class SocketType>

SocketContainer NetworkThread< SocketType >::_sockets

private

template<class SocketType>

std::atomic<bool> NetworkThread< SocketType >::_stopped

private

template<class SocketType>

std::thread* NetworkThread< SocketType >::_thread

private

template<class SocketType>

boost::asio::deadline_timer NetworkThread< SocketType >::_updateTimer

private

---

The documentation for this class was generated from the following file:

• src/server/shared/Networking/NetworkThread.h