ASYNC_SOCKET_HOLDER Class Reference

Spin up a thread to send messages via a socket. More...

Public Member Functions
	ASYNC_SOCKET_HOLDER ()
	~ASYNC_SOCKET_HOLDER ()
bool	Send (int aService, const std::string &aMessage)
	Attempt to send a message if the thread is available. More...

Private Member Functions
void	worker ()
	Actual task that sends data to the socket server. More...

Private Attributes
std::thread	m_thread
std::pair< int, std::string >	m_message
bool	m_messageReady
std::mutex	m_mutex
std::condition_variable	m_cv
bool	m_shutdown

Detailed Description

Spin up a thread to send messages via a socket.

No message queuing, if a message is in flight when another is posted with Send(), the second is just dropped. This is a workaround for "non-blocking" sockets not always being non-blocking, especially on Windows. It is kept fairly simple and not exposed to the outside world because it should be replaced in a future KiCad version with a real message queue of some sort, and unified with the Kiway messaging system.

Definition at line 126 of file eda_dde.cpp.

Constructor & Destructor Documentation

ASYNC_SOCKET_HOLDER()

ASYNC_SOCKET_HOLDER::ASYNC_SOCKET_HOLDER ( )

inline

Definition at line 129 of file eda_dde.cpp.

 :
 m_messageReady( false ),
 m_shutdown( false )
 {
 // Do a dummy Connect so that wx will set up the socket stuff on the main thread, which is
  // required even if you later make socket connections on another thread.
 wxSocketClient* client = new wxSocketClient;
 wxIPV4address addr;
 
 addr.Hostname( HOSTNAME );
 addr.Service( KICAD_PCB_PORT_SERVICE_NUMBER );
 
 client->Connect( addr, false );
 
 client->Close();
 client->Destroy();
 
 m_thread = std::thread( &ASYNC_SOCKET_HOLDER::worker, this );
 }

References HOSTNAME(), KICAD_PCB_PORT_SERVICE_NUMBER, m_thread, and worker().

~ASYNC_SOCKET_HOLDER()

ASYNC_SOCKET_HOLDER::~ASYNC_SOCKET_HOLDER ( )

inline

Definition at line 149 of file eda_dde.cpp.

 {
 {
 std::lock_guard<std::mutex> lock( m_mutex );
 m_shutdown = true;
 }
 
 m_cv.notify_one();
 
 try
 {
 if( m_thread.joinable() )
 m_thread.join();
 }
 catch( ... )
 {
 }
 }

References m_cv, m_mutex, m_shutdown, and m_thread.

Member Function Documentation

Send()

bool ASYNC_SOCKET_HOLDER::Send ( int  aService, const std::string &  aMessage  )

inline

Attempt to send a message if the thread is available.

Parameters

aService	is the port number (i.e. service) to send to.
aMessage	is the message to send.

Returns

true if the message was queued.

Definition at line 175 of file eda_dde.cpp.

 {
 if( m_messageReady )
 return false;
 
 std::lock_guard<std::mutex> lock( m_mutex );
 
 m_message = std::make_pair( aService, aMessage );
 m_messageReady = true;
 m_cv.notify_one();
 
 return true;
 }

References m_cv, m_message, m_messageReady, and m_mutex.

worker()

void ASYNC_SOCKET_HOLDER::worker ( )

inlineprivate

Actual task that sends data to the socket server.

Definition at line 193 of file eda_dde.cpp.

 {
 int port;
 std::string message;
 
 std::unique_lock<std::mutex> lock( m_mutex );
 
 while( !m_shutdown )
 {
 m_cv.wait( lock, [&]() { return m_messageReady || m_shutdown; } );
 
 if( m_shutdown )
 break;
 
 port = m_message.first;
 message = m_message.second;
 
 lock.unlock();
 
 wxSocketClient* sock_client;
 wxIPV4address addr;
 
 // Create a connection
 addr.Hostname( HOSTNAME );
 addr.Service( port );
 
 // Mini-tutorial for Connect() :-)
 // (JP CHARRAS Note: see wxWidgets: sockets/client.cpp sample)
 // ---------------------------
 //
 // There are two ways to use Connect(): blocking and non-blocking,
 // depending on the value passed as the 'wait' (2nd) parameter.
 //
 // Connect(addr, true) will wait until the connection completes,
 // returning true on success and false on failure. This call blocks
 // the GUI (this might be changed in future releases to honor the
 // wxSOCKET_BLOCK flag).
 //
 // Connect(addr, false) will issue a nonblocking connection request
 // and return immediately. If the return value is true, then the
 // connection has been already successfully established. If it is
 // false, you must wait for the request to complete, either with
 // WaitOnConnect() or by watching wxSOCKET_CONNECTION / LOST
 // events (please read the documentation).
 //
 // WaitOnConnect() itself never blocks the GUI (this might change
 // in the future to honor the wxSOCKET_BLOCK flag). This call will
 // return false on timeout, or true if the connection request
 // completes, which in turn might mean:
 //
 // a) That the connection was successfully established
 // b) That the connection request failed (for example, because
 // it was refused by the peer.
 //
 // Use IsConnected() to distinguish between these two.
 //
 // So, in a brief, you should do one of the following things:
 //
 // For blocking Connect:
 //
 // bool success = client->Connect(addr, true);
 //
 // For nonblocking Connect:
 //
 // client->Connect(addr, false);
 //
 // bool waitmore = true;
 // while (! client->WaitOnConnect(seconds, millis) && waitmore )
 // {
 // // possibly give some feedback to the user,
 // // update waitmore if needed.
 // }
 // bool success = client->IsConnected();
 //
 // And that's all :-)
 
 sock_client = new wxSocketClient( wxSOCKET_BLOCK );
 sock_client->SetTimeout( 1 ); // Time out in Seconds
 sock_client->Connect( addr, false );
 sock_client->WaitOnConnect( 0, 250 );
 
 if( sock_client->Ok() && sock_client->IsConnected() )
 {
 sock_client->SetFlags( wxSOCKET_NOWAIT /*wxSOCKET_WAITALL*/ );
 sock_client->Write( message.c_str(), message.length() );
 }
 
 sock_client->Close();
 sock_client->Destroy();
 
 m_messageReady = false;
 
 lock.lock();
 }
 }

References HOSTNAME(), m_cv, m_message, m_messageReady, m_mutex, and m_shutdown.

Referenced by ASYNC_SOCKET_HOLDER().

Member Data Documentation

m_cv

std::condition_variable ASYNC_SOCKET_HOLDER::m_cv

private

Definition at line 293 of file eda_dde.cpp.

Referenced by Send(), worker(), and ~ASYNC_SOCKET_HOLDER().

m_message

std::pair<int, std::string> ASYNC_SOCKET_HOLDER::m_message

private

Definition at line 290 of file eda_dde.cpp.

Referenced by Send(), and worker().

m_messageReady

bool ASYNC_SOCKET_HOLDER::m_messageReady

private

Definition at line 291 of file eda_dde.cpp.

Referenced by Send(), and worker().

m_mutex

std::mutex ASYNC_SOCKET_HOLDER::m_mutex

mutableprivate

Definition at line 292 of file eda_dde.cpp.

Referenced by Send(), worker(), and ~ASYNC_SOCKET_HOLDER().

m_shutdown

bool ASYNC_SOCKET_HOLDER::m_shutdown

private

Definition at line 294 of file eda_dde.cpp.

Referenced by worker(), and ~ASYNC_SOCKET_HOLDER().

m_thread

std::thread ASYNC_SOCKET_HOLDER::m_thread

private

Definition at line 289 of file eda_dde.cpp.

Referenced by ASYNC_SOCKET_HOLDER(), and ~ASYNC_SOCKET_HOLDER().

---

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

• eda_dde.cpp