void ServerClientTest::RunSimple()
{
m_acceptor.reset(m_builder.CreateAcceptor());
m_connector.reset(m_builder.CreateConnector());
m_server = std::make_unique<Server>(*m_acceptor, m_serverThreadPool);
m_client = std::make_unique<Client>(*m_connector, m_clientThreadPool);
m_server->SetCreateChannelHandler(ChannelHandler(this, &ServerClientTest::OnCreateChannel));
m_server->SetMessageHandler(MessageHandler(this, &ServerClientTest::OnServerMessage));
m_server->SetDeleteChannelHandler(ChannelHandler(this, &ServerClientTest::OnDeleteChannel));
m_client->SetMessageHandler(MessageHandler(this, &ServerClientTest::OnClientMessage));
m_server->Start();
std::this_thread::sleep_for(std::chrono::seconds(1));
m_client->Start();
std::this_thread::sleep_for(std::chrono::seconds(5));
m_client->Stop();
std::this_thread::sleep_for(std::chrono::seconds(1));
m_server->Stop();
}
/*-
***********************************************************************
*
* GetModeFinishUp
*
***********************************************************************
*/
int
GetModeFinishUp(FTIMES_PROPERTIES *psProperties, char *pcError)
{
char acMessage[MESSAGE_SIZE];
/*-
*********************************************************************
*
* Print output filenames.
*
*********************************************************************
*/
snprintf(acMessage, MESSAGE_SIZE, "LogFileName=%s", psProperties->acLogFileName);
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
snprintf(acMessage, MESSAGE_SIZE, "OutFileName=%s", psProperties->acOutFileName);
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
/*-
*********************************************************************
*
* Write out the statistics.
*
*********************************************************************
*/
SupportDisplayRunStatistics(psProperties);
return ER_OK;
}
void BaseRenderable::PopulateMessageMap()
{
AddMessageHandler( MessageHandler( MSG_SET_BASE_RENDERSHAPE_LIST, OnSetRenderShapeList ) );
AddMessageHandler( MessageHandler( MSG_FRUSTUM_TEST, OnFrustumTest ) );
AddMessageHandler( MessageHandler( MSG_BUILD_LOCAL_AABB, OnBuildLocalAabb ) );
AddMessageHandler( MessageHandler( MSG_GET_RENDERABLE_COUNT, OnGetRenderableCount ) );
AddMessageHandler( MSG_ATTRIBUTE_CHANGED, OnAttributeChanged );
}
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
EventHookHandler handler = EventHookHandler();
MessageHandler messageHandler = MessageHandler();
ForegroundHook hook = ForegroundHook(handler, messageHandler);
hook.Run();
return 0;
}
int main() {
// Open Message Handler
MessageHandler messageHandler = MessageHandler();
// Print some information on the console
printf("# TrakR %s - Based on CREST - CARS REST API\n", CREST_VERSION);
printf("# (c) 2015 Lars Rosenquist, Nick Garland\n\n");
printf("# Press ESC to terminate\n");
// Keep polling until ESC is hit
while (true) {
// Check for Race State change
if (prevRaceState != messageHandler.getRaceState()){
prevRaceState = messageHandler.getRaceState();
printf("\n\n Race State Changed: %d", messageHandler.getRaceState());
}
// Not started on the grid
if (messageHandler.getRaceState() == 1 && race_id.empty()){
race_id = messageHandler.createRace();
printf("\n\n Race Created: %s", race_id.data());
std::string parts = messageHandler.addParticipants(race_id);
printf("\n\n %s", parts.data());
printf("\n\n Laps Completed: %d", messageHandler.getCompletedLaps());
}
// 2 == RACESTATE_RACING
if (messageHandler.getRaceState() == 2){
// Check if we have completed a lap yet
if (completedLaps < messageHandler.getCompletedLaps()){
//Update complete laps
completedLaps = messageHandler.getCompletedLaps();
printf("\n\n Laps Completed: %d", completedLaps);
//Now ping that server!
printf("\n\n Updated Participants: %s", messageHandler.updateParticipants(race_id));
}
}
// Finish up!
if (messageHandler.getRaceState() == 3 || messageHandler.getRaceState() == 0){
race_id = "";
}
if (_kbhit() && _getch() == ESC_KEY) {
break;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
}
// We're done, free up the server and exit
return 0;
}
//WndProc函数为窗口回调函数，程序中的消息处理都在这个函数中
LRESULT CALLBACK WndProc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
{
switch (umessage)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
case WM_CLOSE:
PostQuitMessage(0);
return 0;
default:
return MessageHandler(hwnd, umessage, wparam, lparam);
}
}
/*-
***********************************************************************
*
* DigModeFinishUp
*
***********************************************************************
*/
int
DigModeFinishUp(FTIMES_PROPERTIES *psProperties, char *pcError)
{
char acMessage[MESSAGE_SIZE];
int i;
int iFirst;
int iIndex;
unsigned char aucFileHash[MD5_HASH_SIZE];
/*-
*********************************************************************
*
* Close up the output stream, and complete the file digest.
*
*********************************************************************
*/
if (psProperties->pFileOut && psProperties->pFileOut != stdout)
{
fflush(psProperties->pFileOut);
fclose(psProperties->pFileOut);
psProperties->pFileOut = NULL;
}
memset(aucFileHash, 0, MD5_HASH_SIZE);
MD5Omega(&psProperties->sOutFileHashContext, aucFileHash);
MD5HashToHex(aucFileHash, psProperties->acOutFileHash);
/*-
*********************************************************************
*
* Print output filenames.
*
*********************************************************************
*/
snprintf(acMessage, MESSAGE_SIZE, "LogFileName=%s", psProperties->acLogFileName);
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
snprintf(acMessage, MESSAGE_SIZE, "OutFileName=%s", psProperties->acOutFileName);
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
snprintf(acMessage, MESSAGE_SIZE, "OutFileHash=%s", psProperties->acOutFileHash);
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
snprintf(acMessage, MESSAGE_SIZE, "DataType=%s", psProperties->acDataType);
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
/*-
*********************************************************************
*
* Write out the statistics.
*
*********************************************************************
*/
snprintf(acMessage, MESSAGE_SIZE, "DirectoriesEncountered=%d", MapGetDirectoryCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
snprintf(acMessage, MESSAGE_SIZE, "FilesEncountered=%d", MapGetFileCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#ifdef UNIX
snprintf(acMessage, MESSAGE_SIZE, "SpecialsEncountered=%d", MapGetSpecialCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#endif
#ifdef WINNT
snprintf(acMessage, MESSAGE_SIZE, "StreamsEncountered=%d", MapGetStreamCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#endif
iIndex = 0;
if (psProperties->iLastAnalysisStage > 0)
{
iIndex = sprintf(&acMessage[iIndex], "AnalysisStages=");
for (i = 0, iFirst = 0; i < psProperties->iLastAnalysisStage; i++)
{
iIndex += sprintf(&acMessage[iIndex], "%s%s", (iFirst++ > 0) ? "," : "", psProperties->asAnalysisStages[i].acDescription);
}
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
snprintf(acMessage, MESSAGE_SIZE, "ObjectsAnalyzed=%u", AnalyzeGetFileCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#ifdef UNIX
#ifdef USE_AP_SNPRINTF
snprintf(acMessage, MESSAGE_SIZE, "BytesAnalyzed=%qu", (unsigned long long) AnalyzeGetByteCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#else
snprintf(acMessage, MESSAGE_SIZE, "BytesAnalyzed=%llu", (unsigned long long) AnalyzeGetByteCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#endif
#endif
#ifdef WIN32
snprintf(acMessage, MESSAGE_SIZE, "BytesAnalyzed=%I64u", AnalyzeGetByteCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
#endif
}
else
{
snprintf(acMessage, MESSAGE_SIZE, "AnalysisStages=None");
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
}
/*-
*********************************************************************
*
* List total number of strings.
*
*********************************************************************
*/
snprintf(acMessage, MESSAGE_SIZE, "DigStrings=%d", DigGetStringCount());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
/*-
*********************************************************************
*
* List total number of strings matched.
*
*********************************************************************
*/
snprintf(acMessage, MESSAGE_SIZE, "DigStringsMatched=%d", DigGetStringsMatched());
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
/*-
*********************************************************************
*
* List total number of matches.
*
*********************************************************************
*/
#ifdef UNIX
#ifdef USE_AP_SNPRINTF
snprintf(acMessage, MESSAGE_SIZE, "TotalMatches=%qu", (unsigned long long) DigGetTotalMatches());
#else
snprintf(acMessage, MESSAGE_SIZE, "TotalMatches=%llu", (unsigned long long) DigGetTotalMatches());
#endif
#endif
#ifdef WIN32
snprintf(acMessage, MESSAGE_SIZE, "MatchCount=%I64u", DigGetTotalMatches());
#endif
MessageHandler(MESSAGE_QUEUE_IT, MESSAGE_INFORMATION, MESSAGE_PROPERTY_STRING, acMessage);
SupportDisplayRunStatistics(psProperties);
return ER_OK;
}
STDMETHODIMP CUUEngine::DFileTo(short row, BSTR outn, long *retVal)
{
uulist *ptr = ue.GetUulp(row);
if (ptr == NULL)
return(CTL_E_INVALIDPROPERTYARRAYINDEX);
if (ptr->filename == NULL || (ptr->state & UUFILE_NODATA))
{
*retVal = UURET_NODATA; // Do data to decode
return(S_OK);
}
MString outname(outn);
char *syserr;
DWORD lasterr;
short rc;
NewStep(); // Let the owner know we're starting a new step
rc = ue.UUDecode(ptr); // Decode and get errors
if (ptr->binfile == NULL)
return(rc); // Couldn't decode/create temp
if (FExist(outname)) { // Deal with an existing output file
if (OWriteOK) { // Overwriting is OK
if (DeleteFile(outname) == FALSE) { // Try to delete it
MessageHandler("Could not delete existing output file", UUMSG_ERROR);
*retVal = UURET_IOERR;
return(S_OK);
}
}
else { // Overwriting not OK
MessageHandler("Output file exists", UUMSG_ERROR);
*retVal = UURET_EXISTS;
return(S_OK);
}
} // Output file doesn't exist. OK to go.
if (MoveFile(ptr->binfile, outname) == FALSE) { // Something went wrong during move
lasterr = ::GetLastError(); // Read the error code
if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
NULL, lasterr, GetUserDefaultLangID(), (LPTSTR) &syserr, 0, NULL) == 0)
MessageHandler("Unknown Error", UUMSG_ERROR); // Couldn't convert error number to string
else {
MessageHandler(syserr, UUMSG_ERROR); // Got a conversion
LocalFree(syserr); // Discard the error string after passing it on
}
*retVal = UURET_IOERR;
return(S_OK);
}
free(ptr->binfile); // Temp file is gone, wasted by MoveFile
ptr->binfile = NULL;
ptr->state = (ptr->state & ~UUFILE_TMPFILE) | UUFILE_DECODED;
*retVal = rc;
return S_OK;
}
STDMETHODIMP CUUEngine::Encode(
BSTR i_iname, BSTR i_oname, BSTR i_nameinfile,
long encoding, long lines, long headers,
VARIANT destvar, VARIANT fromvar, VARIANT subjectvar,
long *retVal)
{
FILE *outf;
int rc, partno;
char *onp, *extp, *partname;
const char *dest, *from, *subject;
MString deststr, fromstr, subjstr;
MString iname(i_iname), oname(i_oname), nameinfile(i_nameinfile);
dest = (const char *) destvar.bstrVal;
if (destvar.vt != VT_BSTR || *dest == EOS)
dest = NULL;
else {
deststr = destvar.bstrVal;
dest = (const char *) deststr;
}
from = (const char *) fromvar.bstrVal;
if (fromvar.vt != VT_BSTR || *from == EOS)
from = NULL;
else {
fromstr = fromvar.bstrVal;
from = (const char *) fromstr;
}
subject = (const char *) subjectvar.bstrVal;
if (subjectvar.vt != VT_BSTR || *subject == EOS)
subject = NULL;
else {
subjstr = subjectvar.bstrVal;
subject = (const char *) subjstr;
}
if (nameinfile != NULL && nameinfile[0] != EOS)
onp = nameinfile.GetBuffer(); // Caller has specified a name
else { // Generate our own
if ((onp = strrchr(iname, '\\')) == NULL) { // Look for last slash
if ((onp = strrchr(iname, ':')) == NULL)
onp = iname.GetBuffer(); // No colons, either
else
onp++; // Point just past colon
}
else
onp++; // Point just past last slash
}
if (lines == 0 && (extp = strrchr(oname, '.')) != NULL) // Set single-part extension
ue.UUSetOption(UUOPT_ENCEXT, 0, extp+1);
if (headers) { // User wants headers
if (lines == 0) { // Single file
if (!OWriteOK && FExist(oname)) { // Can't overwrite output file
MessageHandler("Output file exists", UUMSG_ERROR);
*retVal = UURET_EXISTS;
return(S_OK);
}
if ((outf = fopen(oname, "w")) == NULL) {
MessageHandler("Could not open output file", 1);
*retVal = UURET_IOERR;
return(S_OK);
}
NewStep(); // Warn the owner
if (headers == UUVBE_SIMPLE)
rc = ue.UUEncodeMulti(outf, NULL, iname.GetBuffer(), encoding, onp, NULL, 0);
else
rc = ue.UUE_PrepSingle(outf, NULL, iname.GetBuffer(), encoding, onp, 0,
(char *) dest, (char *) from, (char *) subject, (headers == UUVBE_MAIL));
fclose(outf);
}
else { // Multi part
MString partlocal(oname); // Copy the output name
partname = partlocal.GetBuffer(strlen(oname) + 10); // Grab the buffer
if ((extp = strrchr(partname, '.')) == NULL) { // No extension? Add one...
extp = partname + strlen(partname);
*extp++ = '.';
}
else
extp++; // Just past the last period
partno = 1; // First part
do { // Always have at least one...
sprintf(extp, "%03d", partno);
if (!OWriteOK && FExist(partname)) { // Can't overwrite output file
MessageHandler("Output file exists", UUMSG_ERROR);
*retVal = UURET_EXISTS;
return(S_OK);
}
if ((outf = fopen(partname, "w")) == NULL)
{
MessageHandler("Error opening output file.", 1);
*retVal = UURET_IOERR;
return(S_OK);
}
NewStep(); // Warn the owner
crc32_t lcr = 0;
if (headers == UUVBE_SIMPLE)
rc = ue.UUEncodePartial(outf, NULL, iname.GetBuffer(), encoding, onp, NULL,
0, partno++, (int) lines, &lcr);
else
rc = ue.UUE_PrepPartial(outf, NULL, iname.GetBuffer(), encoding, onp, 0,
partno++, (int) lines, 0, (char *) dest, (char *) from, (char *) subject,
(headers == UUVBE_MAIL));
fclose(outf);
} while (rc == UURET_CONT);
}
}
else {
NewStep(); // Warn the owner
rc = ue.UUEncodeToFile(NULL, iname.GetBuffer(), encoding,
onp, oname.GetBuffer(), (int) lines);
}
*retVal = rc;
return S_OK;
}
void Physics::PopulateMessageMap(void)
{
AddMessageHandler( MessageHandler( PhysicsMessages::MSG_UPDATE, OnUpdate ) );
AddMessageHandler( MessageHandler( PhysicsMessages::MSG_APPLY_FORCE, OnApplyForce ) );
AddMessageHandler( MessageHandler( PhysicsMessages::MSG_APPLY_REACTION, OnApplyReaction ) );
}
void SkyBoxBehavior::PopulateMessageMap()
{
AddMessageHandler( MessageHandler( SkyBoxBehaviorMessages::MSG_BUILD_LOCAL_AABB,
OnBuildLocalAabb ) );
}
void TurnToBehavior::PopulateMessageMap(void)
{
AddMessageHandler( MessageHandler( TurnToBehaviorMessages::MSG_SET_TARGET, OnSetTarget ) );
AddMessageHandler( MessageHandler( TurnToBehaviorMessages::MSG_UPDATE, OnUpdate ) );
}
void TurretBehavior::PopulateMessageMap(void)
{
AddMessageHandler( MessageHandler( TurretBehaviorMessages::MSG_ROTATE_RIGHT, OnRotateRight ) );
AddMessageHandler( MessageHandler( TurretBehaviorMessages::MSG_ROTATE_LEFT, OnRotateLeft ) );
AddMessageHandler( MessageHandler( TurretBehaviorMessages::MSG_RIGHT_JOYSTICK, OnRightStick ) );
}
#include "SharedMemoryRenderer.h"
// Configuration properties
#define CREST_VERSION "v0.1"
#define POLL_TIME_IN_MILLIS 17
#define ESC_KEY 27
#define CREST_API_URL "/crest/v1/api"
// Constants
#define HTTP_RESPONSE_404 "{\"status\": \"404 Not found, please use the correct URL: " CREST_API_URL "\"}"
// Server variables
// Response generator
static MessageHandler messageHandler = MessageHandler();
static SharedMemoryRenderer sharedMemoryRenderer = SharedMemoryRenderer();
// Server request handler method
//httpMessageHandler.handle(nc, hm);
std::string race_id = "";
int prevRaceState = 0;
int completedLaps = 0;
int main() {
// Open Message Handler
MessageHandler messageHandler = MessageHandler();
// Print some information on the console
printf("# TrakR %s - Based on CREST - CARS REST API\n", CREST_VERSION);
printf("# (c) 2015 Lars Rosenquist, Nick Garland\n\n");
void CameraBehavior::PopulateMessageMap(void)
{
AddMessageHandler( MessageHandler( CameraBehaviorMessages::MSG_SET_PORT_INDEX, OnSetViewPortIndex ) );
AddMessageHandler( MessageHandler( CameraBehaviorMessages::MSG_UPDATE, OnUpdate ) );
AddMessageHandler( MessageHandler( CameraBehaviorMessages::MSG_BUILD_PROJECTION, OnBuildProjection ) );
}
void GroundClamp::PopulateMessageMap(void)
{
AddMessageHandler( MessageHandler( GroundClampMessages::MSG_COLLIDE, OnCollide ) );
AddMessageHandler( MessageHandler( GroundClampMessages::MSG_UPDATE, OnUpdate ) );
}
