C++ (Cpp) MessageReady 예제들

예제 #1

파일: debug.cpp 프로젝트: BackupTheBerlios/wolfpack-svn

/********************************************************
 *                                                      *
 *  Rountine to process and stamp a message.            *
 *                                                      *
 ********************************************************/
void LogMessageF(unsigned char Type, long Line, char *File, char *Message, ...)
{
	char fullMessage[512];
	char builtMessage[512];
	va_list argptr;

	va_start(argptr, Message);
	vsprintf(builtMessage, Message, argptr);
	va_end(argptr);

	char timestamp[60];

	time_t currentTime;
	tm *ct;
	time(&currentTime);
	ct = gmtime(&currentTime);
	sprintf(timestamp, "%c:[%2d.%02d][%2d:%02d:%02d]", Type, ct->tm_mday, ct->tm_mon, ct->tm_hour, ct->tm_min, ct->tm_sec);
//#endif

	if (Type=='M')
		strcpy(fullMessage,timestamp);	// no debug info for normal messages (Duke)
	else
		sprintf(fullMessage, "%s %s:%ld ", timestamp, File, Line);
	strcat(fullMessage, builtMessage);
	strcat(fullMessage, "\n");
	MessageReady(fullMessage,Type);
}

예제 #2

파일: RemotePlayer.cpp 프로젝트: Belotus/Belotus

RemotePlayer::RemotePlayer(QTcpSocket *socket, CardFactory *cardFactory)
    : Player(), protocol(new Protocol(socket, cardFactory))
{
    qDebug() << "RemotePlayer : Constructeur" ;
    connect(this->protocol, SIGNAL(s_MessageReady(quint32)), this, SLOT(MessageReady(quint32)));
    qDebug() << "RemotePlayer : Fin constructeur" ;
}

예제 #3

파일: ListenerSocket.cpp 프로젝트: coder4hire/BBNotifier

void CListenerSocket::incomingConnection(qintptr socketDescriptor)
{
    CServerSocket * pSock = new CServerSocket();
    pSock->setSocketDescriptor(socketDescriptor);
    connect(pSock,SIGNAL(MessageReady(QString)),this,SLOT(OnIncomingMessage(QString)));
    serverSockets.push_back(pSock);
    addPendingConnection(pSock);
    nextPendingConnection();
}

예제 #4

파일: remoteminerclient.cpp 프로젝트: Tania188/rpcminer-optcuda

void RemoteMinerClient::Run(const std::string &server, const std::string &port, const std::string &password, const std::string &address, const int threadcount)
{
	int64 lastrequestedwork=GetTimeMillis();

	//debug
	int64 starttime=0;
	int64 hashcount=0;
	int64 lastdisplay=0;

	std::cout << "Client will start " << threadcount << " miner threads" << std::endl;

	while(true)
	{
		if(IsConnected()==false)
		{
			m_minerthreads.Stop();
			std::cout << "Attempting to connect to " << server << ":" << port << std::endl;
			Sleep(1000);
			if(Connect(server,port))
			{
				m_minerthreads.Start(new threadtype);
				m_gotserverhello=false;
				std::cout << "Connected to " << server << ":" << port << std::endl;
				SendClientHello(password,address);
				lastrequestedwork=GetTimeMillis();

				//debug
				starttime=GetTimeMillis();
			}
		}
		else
		{
			Update();

			while(MessageReady() && !ProtocolError())
			{
				RemoteMinerMessage message;
				if(ReceiveMessage(message))
				{
					if(message.GetValue().type()==json_spirit::obj_type)
					{
						HandleMessage(message);
					}
					else
					{
						std::cout << "Unexpected json type sent by server.  Disconnecting." << std::endl;
						Disconnect();
					}
				}
			}

			if(ProtocolError())
			{
				std::cout << "Protocol error.  Disconnecting." << std::endl;
				Disconnect();
			}

			if(m_minerthreads.RunningThreadCount()<threadcount)
			{
				m_minerthreads.Start(new threadtype);
			}

			if(m_minerthreads.HaveFoundHash())
			{
				std::cout << "Found Hash!" << std::endl;
				RemoteMinerThread::foundhash fhash;
				m_minerthreads.GetFoundHash(fhash);
				SendFoundHash(fhash.m_blockid,fhash.m_nonce);
				SendWorkRequest();
			}

			while(m_minerthreads.HaveHashResult())
			{
				RemoteMinerThread::hashresult hresult;

				m_minerthreads.GetHashResult(hresult);

				SendMetaHash(hresult.m_blockid,hresult.m_metahashstartnonce,hresult.m_metahashdigest,hresult.m_besthash,hresult.m_besthashnonce);

				//debug
				//std::cout << "sent result " << hresult.m_blockid << " " << hresult.m_metahashstartnonce << " " << hresult.m_besthashnonce << std::endl;
				hashcount+=m_metahashsize;

				if(hresult.m_metahashstartnonce>4000000000 && (lastrequestedwork+5000)<GetTimeMillis())
				{
					std::cout << "Requesting a new block " << GetTimeMillis() << std::endl;
					SendWorkRequest();
					lastrequestedwork=GetTimeMillis();
				}
			}

			if(m_minerthreads.NeedWork())
			{
				if((lastrequestedwork+6000)<GetTimeMillis())
				{
					std::cout << "Requesting a new block " << GetTimeMillis() << std::endl;
					SendWorkRequest();
					lastrequestedwork=GetTimeMillis();
				}
			}

			//debug
			if(lastdisplay+10000<=GetTimeMillis())
			{
				if(((GetTimeMillis()-starttime)/1000)>0)
				{
					//std::cout << hashcount/((GetTimeMillis()-starttime)/1000) << std::endl;
					//std::cout << "sendsize=" << m_sendbuffer.size() << std::endl;
					lastdisplay=GetTimeMillis();
				}
			}

		}
	}

}