C++ receiveMessage函数代码示例

uInt8 sim_ReadDigitalU8(uInt32 port)
{
	char buff[100];
	char lixo[100];
	uInt32 value;

	sprintf(buff,"%s %02X %02X","ReadDigitalU8", port, 0);
	
	sendMessage(buff);	

	receiveMessage(buff);

	
	sscanf(buff,"%s %02X %02X",lixo, &port, &value);
	return((uInt8) value);
}

        // Receives a message.
        // The message is represented as a list of byte arrays representing
        // a message's parts. If the message is not a multi-part message the
        // list will only contain one array.
        inline QList<QByteArray> receiveMessage()
        {
            QList<QByteArray> parts;

            ZMQMessage msg;
            while (receiveMessage(&msg))
            {
                parts += msg.toByteArray();
                msg.rebuild();

                if (!hasMoreMessageParts())
                    break;
            }

            return parts;
        }

// Receive notification that the SSL handshake has completed successfully
void Server::handshakeComplete()
{
  QSslSocket *socket = dynamic_cast<QSslSocket *>(sender());
  assert(socket);

  connect(socket, SIGNAL(disconnected()), this, SLOT(connectionClosed()));
  connect(socket, SIGNAL(readyRead()), this, SLOT(receiveMessage()));

  ui->logTextEdit->append(QString("[%1] Accepted connection from %2:%3")
                          .arg(QDateTime::currentDateTime().toString("hh:mm:ss.zzz ap"))
                          .arg(socket->peerAddress().toString())
                          .arg(socket->peerPort()));

  sockets.push_back(socket);
  users.push_back(socket->peerPort());
}

LocalSocketIpcClient::LocalSocketIpcClient(QString remoteServername, QObject *parent) :
        QObject(parent)
{

    m_socket = new QLocalSocket(this);
    m_serverName = remoteServername;

    connect(m_socket, SIGNAL(connected()), this, SLOT(socket_connected()));
    connect(m_socket, SIGNAL(disconnected()), this, SLOT(socket_disconnected()));

    m_socket->connectToServer(m_serverName, QLocalSocket::ReadWrite);

    connect(m_socket, SIGNAL(readyRead()), this, SLOT(receiveMessage()));
    connect(m_socket, SIGNAL(error(QLocalSocket::LocalSocketError)),
            this, SLOT(socket_error(QLocalSocket::LocalSocketError)));
}

NZMQT_INLINE QList<QByteArray> ZMQSocket::receiveMessage(ReceiveFlags flags_)
{
    QList<QByteArray> parts;

    ZMQMessage msg;
    while (receiveMessage(&msg, flags_))
    {
        parts += msg.toByteArray();
        msg.rebuild();

        if (!hasMoreMessageParts())
            break;
    }

    return parts;
}

void sendMessage(uint8_t send_list) {
  uint8_t i, tries, channel, send_mask;

  // send to only good channels
  send_list &= ALL_GOOD_CHANNELS;
    
  
  for (tries=TX_TRIES; tries>0; tries--) {

    handshake_retry_addition = (tries * RETRY_INCREMENT);

    //trying to make it do the sendMessage more times on failed channels
    send_mask = 0x01;
    for (channel=1; channel<=MAX_CHANNELS; channel++) {
      uint8_t good_tx = TRUE;
      if (send_list & send_mask) {
	//putnum_ud(channel);
	/*
	 * Check if the line to transmit on is already being used.
	 * If so, receive the message and then carry on.
	 */
	if (pollClockLine(channel) == 0) {
	  receiveMessage(channel);
	}
	for (i=0; i<num_bytes_in_tx_msg_buff; i++) {
	  if (sendByte(tx_msg_buff[i], channel) == FALSE) {
	    //the message was not received.
	    //mark this channel not to be cleared from sendList so it can be resent later.
	    good_tx = FALSE;
	    break;
	  }
	  else
	    good_tx = TRUE;
	}
      }
      if (good_tx == TRUE) {
	send_list &= ~send_mask;  //tx was good. clear the bit from sendList to avoid resending
      }
      send_mask <<= 1; // try sending to the next channel
    }
  }
  // update goodChannels to remove channels that did not succeed
  // this works because sendList keeps track of which channels have not received the message yet.
  good_channels &= ~send_list;
  num_bytes_in_tx_msg_buff = 0;
}

void * recebedorDados(void * lixo){
	char message[MAXSIZE];

	while(true){
		receiveMessage(fdSocket,message,sizeof(int));
		if((rand()%100)<95 ){
			printf("recebeu %s \n",message);
			if((rand()%100)<90 ){
				sendMessage(fdSocket,message,sizeof(int)); //Envia mensagem
				printf("confirmou %s \n",message);
			}else{
				printf("falha na confirmação\n");
			}
		}
	}
	printf("acabou recebedor \n");
}

/**
 * Execute a transaction with a Jaguar that gets some property.
 * 
 * Jaguar always generates a message with the same message ID when replying.
 * 
 * @param messageID The messageID to read from the CAN bus (device number is added internally)
 * @param data The up to 8 bytes of data that was received with the message
 * @param dataSize Indicates how much data was received
 */
void CANJaguar::getTransaction(UINT32 messageID, UINT8 *data, UINT8 *dataSize)
{
	UINT32 targetedMessageID = messageID | m_deviceNumber;
	INT32 status = 0;

	// Make sure we don't have more than one transaction with the same Jaguar outstanding.
	semTake(m_transactionSemaphore, WAIT_FOREVER);

	// Send the message requesting data.
	status = sendMessage(targetedMessageID, NULL, 0);
	wpi_assertCleanStatus(status);
	// Wait for the data.
	status = receiveMessage(&targetedMessageID, data, dataSize);
	wpi_assertCleanStatus(status);

	// Transaction complete.
	semGive(m_transactionSemaphore);
}

void Client::listMails() {
    std::string message = "LIST\n";

    sendReceive(message);	// status message
    receiveMessage(message);	// data

    if (message.length() == 3) {	// = ".CRLF"
        std::cout << "No new messages" << std::endl;
        return;
    }

    if (shortMessage) {
        // remove last dot + CRLF
        message.erase( message.length() - 3, 3);
    }

    std::cout << message;
}

    Message::Result Scene::sendMessage(const Message& message)
    {
        if (message.passFilter(getID()))
        {
            if ((message.passFilter(Message::Scene) || (this == &Engine::getSharedScene() && message.passFilter(Message::SharedScene))))
            {
                if (receiveMessage(message) == Message::Result::Escape)
                    return Message::Result::Escape;
            }
        }

        const unsigned short objectField = Message::Object | Message::Component;

        if (message.passFilter(objectField) && Object::sendMessage(message) == Message::Result::Escape)
            return Message::Result::Escape;

        return Message::Result::Continue;
    }

Application::Application(int &argc, char *argv[])
    : QApplication(argc, argv)
    , d_ptr(new ApplicationPrivate)
{
    Q_D(Application);

    d->isRunning = false;
    d->sharedMemory.setKey(GUI_APPLICATION_SHARED_MEMORY_KEY);

    if (d->sharedMemory.attach()) {
        d->isRunning = true;
    } else {
        if (!d->sharedMemory.create(1))
            return;
        connect(&d->localServer, SIGNAL(newConnection()), SLOT(receiveMessage()));
        d->localServer.listen(GUI_APPLICATION_SHARED_MEMORY_KEY);
    }
}

//--------------------------------------------------------------
void ofApp::update(){
	if (client.isConnected() && started) {
		vector<ofxJSONElement> elements = receiveMessage();

		for (int i = 0; i < elements.size(); i++) {
			ofxJSONElement element = new ofxJSONElement();

			element = elements[i];

			//if data frame
			for (Json::ArrayIndex i = 0; i < element["DATA"].size(); i++) {
				//get element at index i
				ofxJSONElement sub = elements[i]["DATA"][i];
				//display value type and timestamp
				cout << "received " << sub["ID"].asString() << " at " << sub["Timestamp"].asFloat() << " ";

				//end line
				cout << endl;

				//store eeg values				
				if (sub["ID"].asString() == "eeg_alpha") fitEegData(sub, eegAlpha);
				if (sub["ID"].asString() == "eeg_beta") fitEegData(sub, eegBeta);
				if (sub["ID"].asString() == "eeg_theta") fitEegData(sub, eegTheta);

				//store eda values				
				if (sub["ID"].asString() == "eda_tonic") fitEdaData(sub, edaFasic);
				if (sub["ID"].asString() == "eda_fasic") fitEdaData(sub, edaTonic);

				//store ecg values
				if (sub["ID"].asString() == "ecg_hr") ecg = sub["Values"][0].asFloat();
				
			}
			if (element["STATUS"].asString() == "OK") {
				//if request accepted
				started = true;
				cout << "start request accepted." << endl;
			}
			else if (element["STATUS"].asString() == "Error") {
				//error in the server when receiving the message
				ofLogError(element["MSG"].asString());
			}
		}
	}	
}

Socket::Socket(std::string const &serv, int port)
{
  struct protoent	*pe;
  struct sockaddr_in	sockaddr;
  socklen_t		socksize;
  int			sock;
  int			okay;

  pe = getprotobyname("TCP");
  socksize = sizeof(struct sockaddr);
  if ((sock = socket(AF_INET, SOCK_STREAM, pe->p_proto)) == -1)
    {
      std::cerr << "Socket creation failed." << std::endl;
      exit(2);
    }
  sockaddr.sin_family = AF_INET;
  sockaddr.sin_port = htons(port);
  sockaddr.sin_addr.s_addr = inet_addr(serv.c_str());
  if ((connect(sock, reinterpret_cast<const struct sockaddr *>(&sockaddr), socksize)) != 0)
    {
      std::cerr << "Socket connection failed." << std::endl;
      exit(3);
    }
  m_sock = sock;
  m_fds.fd = m_sock;
  m_fds.events = POLLIN;
  okay = 0;
  if (toRead())
    {
      okay = 1;
      if (receiveMessage() != "BIENVENUE")
	okay = 0;
    }
  if (okay)
    {
      m_okay = true;
      sendMessage("GRAPHIC");
    }
  else
    {
      m_okay = false;
      std::cerr << "\'BIENVENUE\' not received..." << std::endl << "Exiting ..." << std::endl;
    }
}

//This does the actual sending of the message
//modifies: nothing
//effects: send message in the Q_tx_msg_buff on the channel
//NOTE: This method does NOT mess with or consider anything having to do with the channelQueuesArray at all
uint8_t rbSendMessageHelper(uint8_t channel, uint8_t message[], uint8_t messageLength) {
  if (channel <= 0 || channel > MAX_CHANNELS) {
    //putstring("\nINVALID CHANNEL PASSED TO rbSendMessageHelper:  ");  putnum_uh(channel);
    while (1) {
      blinkRed(14);
      blinkOrange(14);
    }
  }
  
  disableRTC2();
  
  if (pollClockLine(channel) == 0) {
    //putstring("\n about to ATTEMPT TO RECEIVE BEFORE SENDING on channel: "); putnum_ud(channel);
    ReceiveMessagePacket incomingPacket = receiveMessage(channel);
    if (incomingPacket.messageLength != 0) {
      //valid message, but it in the pending processing buffer
      //putstring("\nReceived Message before sending on channel "); putnum_ud(channel);
      //putstring("   Adding message to process pending queue");
      addProcessPendingMsg(incomingPacket);
    }
  }
  
  uint8_t i;
  uint8_t good_tx = TRUE;
  for (i = 0; i < messageLength; i++) {
    if (sendByte(message[i], channel) == FALSE) {
      //the message was not received.
      //putstring("failed to send a byte");
      good_tx = FALSE;
      break;
       }
    else
      good_tx = TRUE;

    refreshChannel(channel); //able to send at least 1 byte
  }
  
  /*if (channel == 1 && !good_tx)
   {
   putstring("\nch1 send failure\n");
   }*/
  enableRTC2();
  return good_tx;
}

 ReceiveMessageResponse*
 SQSConnection::receiveMessage (const std::string &aQueueUrl,
                                int aNumberOfMessages,
                                int aVisibilityTimeout,
                                bool aDecode) {
   ParameterMap lMap;
   if (aNumberOfMessages != 0) {
       std::stringstream s;
       s << aNumberOfMessages;
       lMap.insert (ParameterPair ("MaxNumberOfMessages", s.str()));
     }
   if (aVisibilityTimeout > -1) {
       std::stringstream s;
       s << aVisibilityTimeout;
       lMap.insert (ParameterPair ("VisibilityTimeout", s.str()));
     }
 
   return receiveMessage (aQueueUrl, lMap, aDecode);
 }