backup/barrier
1
0
Fork 0
mirror of https://github.com/debauchee/barrier.git synced 2026-05-07 22:23:12 +08:00
Code Issues Projects Releases Wiki Activity

dropped "c" prefix from class names

Browse Source
This commit is contained in:
Nick Bolton
2014-11-11 13:51:47 +00:00
parent f6c05e7635
commit e8e156f0e2
382 changed files with 7430 additions and 7423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
src/lib/ipc/IpcClientProxy.cpp
View File

@@ -27,10 +27,10 @@
#include "base/Log.h"
//
// CIpcClientProxy
// IpcClientProxy
//
CIpcClientProxy::CIpcClientProxy(synergy::IStream& stream, IEventQueue* events) :
IpcClientProxy::IpcClientProxy(synergy::IStream& stream, IEventQueue* events) :
m_stream(stream),
m_clientType(kIpcClientUnknown),
m_disconnecting(false),
@@ -40,26 +40,26 @@ CIpcClientProxy::CIpcClientProxy(synergy::IStream& stream, IEventQueue* events)
{
m_events->adoptHandler(
m_events->forIStream().inputReady(), stream.getEventTarget(),
new TMethodEventJob<CIpcClientProxy>(
this, &CIpcClientProxy::handleData));
new TMethodEventJob<IpcClientProxy>(
this, &IpcClientProxy::handleData));
m_events->adoptHandler(
m_events->forIStream().outputError(), stream.getEventTarget(),
new TMethodEventJob<CIpcClientProxy>(
this, &CIpcClientProxy::handleWriteError));
new TMethodEventJob<IpcClientProxy>(
this, &IpcClientProxy::handleWriteError));
m_events->adoptHandler(
m_events->forIStream().inputShutdown(), stream.getEventTarget(),
new TMethodEventJob<CIpcClientProxy>(
this, &CIpcClientProxy::handleDisconnect));
new TMethodEventJob<IpcClientProxy>(
this, &IpcClientProxy::handleDisconnect));
m_events->adoptHandler(
m_events->forIStream().outputShutdown(), stream.getEventTarget(),
new TMethodEventJob<CIpcClientProxy>(
this, &CIpcClientProxy::handleWriteError));
new TMethodEventJob<IpcClientProxy>(
this, &IpcClientProxy::handleWriteError));
}
CIpcClientProxy::~CIpcClientProxy()
IpcClientProxy::~IpcClientProxy()
{
m_events->removeHandler(
m_events->forIStream().inputReady(), m_stream.getEventTarget());
@@ -82,24 +82,24 @@ CIpcClientProxy::~CIpcClientProxy()
}
void
CIpcClientProxy::handleDisconnect(const CEvent&, void*)
IpcClientProxy::handleDisconnect(const Event&, void*)
{
disconnect();
LOG((CLOG_DEBUG "ipc client disconnected"));
}
void
CIpcClientProxy::handleWriteError(const CEvent&, void*)
IpcClientProxy::handleWriteError(const Event&, void*)
{
disconnect();
LOG((CLOG_DEBUG "ipc client write error"));
}
void
CIpcClientProxy::handleData(const CEvent&, void*)
IpcClientProxy::handleData(const Event&, void*)
{
// don't allow the dtor to destroy the stream while we're using it.
CArchMutexLock lock(m_readMutex);
ArchMutexLock lock(m_readMutex);
LOG((CLOG_DEBUG "start ipc handle data"));
@@ -110,7 +110,7 @@ CIpcClientProxy::handleData(const CEvent&, void*)
LOG((CLOG_DEBUG "ipc read: %c%c%c%c",
code[0], code[1], code[2], code[3]));
CIpcMessage* m = nullptr;
IpcMessage* m = nullptr;
if (memcmp(code, kIpcMsgHello, 4) == 0) {
m = parseHello();
}
@@ -123,7 +123,7 @@ CIpcClientProxy::handleData(const CEvent&, void*)
}
// don't delete with this event; the data is passed to a new event.
CEvent e(m_events->forCIpcClientProxy().messageReceived(), this, NULL, CEvent::kDontFreeData);
Event e(m_events->forIpcClientProxy().messageReceived(), this, NULL, Event::kDontFreeData);
e.setDataObject(m);
m_events->addEvent(e);
@@ -134,25 +134,25 @@ CIpcClientProxy::handleData(const CEvent&, void*)
}
void
CIpcClientProxy::send(const CIpcMessage& message)
IpcClientProxy::send(const IpcMessage& message)
{
// don't allow other threads to write until we've finished the entire
// message. stream write is locked, but only for that single write.
// also, don't allow the dtor to destroy the stream while we're using it.
CArchMutexLock lock(m_writeMutex);
ArchMutexLock lock(m_writeMutex);
LOG((CLOG_DEBUG4 "ipc write: %d", message.type()));
switch (message.type()) {
case kIpcLogLine: {
const CIpcLogLineMessage& llm = static_cast<const CIpcLogLineMessage&>(message);
CString logLine = llm.logLine();
CProtocolUtil::writef(&m_stream, kIpcMsgLogLine, &logLine);
const IpcLogLineMessage& llm = static_cast<const IpcLogLineMessage&>(message);
String logLine = llm.logLine();
ProtocolUtil::writef(&m_stream, kIpcMsgLogLine, &logLine);
break;
}
case kIpcShutdown:
CProtocolUtil::writef(&m_stream, kIpcMsgShutdown);
ProtocolUtil::writef(&m_stream, kIpcMsgShutdown);
break;
default:
@@ -161,34 +161,34 @@ CIpcClientProxy::send(const CIpcMessage& message)
}
}
CIpcHelloMessage*
CIpcClientProxy::parseHello()
IpcHelloMessage*
IpcClientProxy::parseHello()
{
UInt8 type;
CProtocolUtil::readf(&m_stream, kIpcMsgHello + 4, &type);
ProtocolUtil::readf(&m_stream, kIpcMsgHello + 4, &type);
m_clientType = static_cast<EIpcClientType>(type);
// must be deleted by event handler.
return new CIpcHelloMessage(m_clientType);
return new IpcHelloMessage(m_clientType);
}
CIpcCommandMessage*
CIpcClientProxy::parseCommand()
IpcCommandMessage*
IpcClientProxy::parseCommand()
{
CString command;
String command;
UInt8 elevate;
CProtocolUtil::readf(&m_stream, kIpcMsgCommand + 4, &command, &elevate);
ProtocolUtil::readf(&m_stream, kIpcMsgCommand + 4, &command, &elevate);
// must be deleted by event handler.
return new CIpcCommandMessage(command, elevate != 0);
return new IpcCommandMessage(command, elevate != 0);
}
void
CIpcClientProxy::disconnect()
IpcClientProxy::disconnect()
{
LOG((CLOG_DEBUG "ipc disconnect, closing stream"));
m_disconnecting = true;
m_stream.close();
m_events->addEvent(CEvent(m_events->forCIpcClientProxy().disconnected(), this));
m_events->addEvent(Event(m_events->forIpcClientProxy().disconnected(), this));
}