C++ MessageBuffer类代码示例

void CheriaServer::sendClientConnect(ProtocolServer::ClientState* sourceCs,ProtocolServer::ClientState* destCs,Comm::NetPipe& pipe)
	{
	/* Get handles on the Cheria state objects: */
	ClientState* mySourceCs=dynamic_cast<ClientState*>(sourceCs);
	ClientState* myDestCs=dynamic_cast<ClientState*>(destCs);
	if(mySourceCs==0||myDestCs==0)
		Misc::throwStdErr("CheriaServer::sendClientConnect: Client state object has mismatching type");
	
	#if DEBUGGING
	std::cout<<"CheriaServer::sendClientConnect..."<<std::flush;
	#endif
	
	/* Create a temporary message buffer with the same endianness as the pipe's write end: */
	MessageBuffer buffer;
	buffer.setSwapOnWrite(pipe.mustSwapOnWrite());
	
	/*********************************************************************
	Assemble the update message in the temporary buffer:
	*********************************************************************/
	
	/* Send creation messages for the source client's devices to the destination client: */
	for(ClientDeviceMap::Iterator cdIt=mySourceCs->clientDevices.begin();!cdIt.isFinished();++cdIt)
		{
		writeMessage(CREATE_DEVICE,buffer);
		buffer.write<Card>(cdIt->getSource());
		cdIt->getDest()->writeLayout(buffer);
		}
	
	/* Send creation messages for the source client's tools to the destination client: */
	for(ClientToolMap::Iterator ctIt=mySourceCs->clientTools.begin();!ctIt.isFinished();++ctIt)
		{
		writeMessage(CREATE_TOOL,buffer);
		buffer.write<Card>(ctIt->getSource());
		ctIt->getDest()->write(buffer);
		}
	
	/* Send the current states of the source client's devices: */
	writeMessage(DEVICE_STATES,buffer);
	for(ClientDeviceMap::Iterator cdIt=mySourceCs->clientDevices.begin();!cdIt.isFinished();++cdIt)
		{
		/* Send a device state message: */
		buffer.write<Card>(cdIt->getSource());
		cdIt->getDest()->write(DeviceState::FULL_UPDATE,buffer);
		}
	buffer.write<Card>(0);
	
	/*********************************************************************
	Send the assembled message to the client in one go:
	*********************************************************************/
	
	#if DEBUGGING
	std::cout<<" message size "<<buffer.getDataSize()<<std::endl;
	#endif
	
	/* Write the message's total size first: */
	pipe.write<Card>(buffer.getDataSize());
	
	/* Write the message itself: */
	buffer.writeToSink(pipe);
	}

inline bool PartialProcessPacket(Battlenet::Session* session, MessageBuffer& inputBuffer)
{
    MessageBuffer& buffer = session->*outputBuffer;

    // We have full read header, now check the data payload
    if (buffer.GetRemainingSpace() > 0)
    {
        // need more data in the payload
        std::size_t readDataSize = std::min(inputBuffer.GetActiveSize(), buffer.GetRemainingSpace());
        buffer.Write(inputBuffer.GetReadPointer(), readDataSize);
        inputBuffer.ReadCompleted(readDataSize);
    }

    if (buffer.GetRemainingSpace() > 0)
    {
        // Couldn't receive the whole data this time.
        ASSERT(inputBuffer.GetActiveSize() == 0);
        return false;
    }

    // just received fresh new payload
    if (!(session->*processMethod)())
    {
        session->CloseSocket();
        return false;
    }

    return true;
}

MessageBuffer *Session::ReadMessage() {
	unsigned char len_buf[4];
	unsigned char *buf = NULL;
	unsigned long msg_len;
	read_monitor.Enter();
	try {
		if (ReadData(len_buf, 0, 4) != 4)
			throw MessageException("Unable to read data");
		unsigned long msg_len_net = *((unsigned int *)len_buf);
		msg_len = ntohl(msg_len_net);
		buf = new unsigned char[msg_len];
		if (ReadData(buf, 0, msg_len) != msg_len)
			throw MessageException("Unable to read data");
	} catch (...) {
		read_monitor.Exit();
		if (buf != NULL)
			delete[] buf;
		throw;
	}
	read_monitor.Exit();

	MessageBuffer *rv = new MessageBuffer();
	try {
		rv->SetData(buf, msg_len);
	} catch (...) {
		delete[] buf;
		delete rv;
		throw;
	}
	delete[] buf;
	return rv;
}

void TellMasterThatWorkerStartedAWorkUnit( MessageBuffer &mb, CDSInfo *pInfo, WUIndexType iWU )
{
    mb.setLen( 0 );
    PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WU_STARTED );
    mb.write( &iWU, sizeof( iWU ) );
    VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID, k_eVMPISendFlags_GroupPackets );
}

void PreDistributeWorkSync( CDSInfo *pInfo )
{
    if ( g_bMPIMaster )
    {
        // Send a message telling all the workers we're ready to go on this DistributeWork call.
        MessageBuffer mb;
        PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_MASTER_READY );
        VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT );
    }
    else
    {
        if ( g_iVMPIVerboseLevel >= 1 )
            Msg( "PreDistributeWorkSync: waiting for master\n" );

        // Wait for the master's message saying it's ready to go.
        while ( g_iMasterReadyForDistributeWorkCall < g_iCurDSInfo )
        {
            VMPI_DispatchNextMessage();
        }

        if ( g_iVMPIVerboseLevel >= 1 )
            Msg( "PreDistributeWorkSync: master ready\n" );

        // Now tell the master we're ready.
        MessageBuffer mb;
        PrepareDistributeWorkHeader( &mb, DW_SUBPACKETID_WORKER_READY );
        VMPI_SendData( mb.data, mb.getLen(), VMPI_MASTER_ID );
    }
}

 // Called when the metadata object is about to be written
 // FIll the fields on the metadata
 virtual void compute_info(const MessageBuffer& buffer)
 {
     ProcessingStep& p = *_processing_step;
     
     p.set_name("root2a4");
 
     p.set_walltime((chrono::steady_clock::now() - _start_wallclock).count());
     p.set_cputime((chrono::thread_clock::now() - _start_cpuclock).count());
     
     p.set_input_events(_input_events);
     p.set_input_bytes_read(_input_bytes_read);
     
     _metadata.set_event_count(buffer.size());
     
     if (buffer.size() >= 1) {
         if (_field_run) {
             auto run_number = _refl->GetUInt32(*buffer[0], _field_run);
             _metadata.add_run(run_number);
             
             auto* full_period = get_period(run_number);
             std::string period = full_period;
             
             if (period != "UNK") {
                 period = period[0];
             }
             
             _metadata.add_period(period);
             _metadata.add_subperiod(full_period);
         }
         if (_field_mc_channel && _refl->HasField(*buffer[0], _field_mc_channel)) 
             _metadata.add_mc_channel(_refl->GetUInt32(*buffer[0], _field_mc_channel));
     }
 }

  void LedHandler::process_messages()
  {
      MessageBuffer* buf = _blk->getBuffer();
    //  cout << "led process" <<endl;
      google::protobuf::Message* cur = buf->remove_head();
      while(cur != 0)
      {
	  if(cur->GetTypeName() != "LedChangeMessage")
	  {
	      cout << "not led" << endl;
	      delete cur;
	      cur = buf->remove_head();
	      continue;
	  }

	  LedChangeMessage* led_change = (LedChangeMessage*)cur;

	  for(int i = 0; i < led_change->leds_size(); i++)
	  {

	      setLed(led_change->leds(i).chain(),led_change->leds(i).color());

	  }

	  delete cur;
	  cur = buf->remove_head();

      }


  }

void ChatRoom::Deliver(const ChatMessage& chat)
{
    MessageBuffer msgs;
    auto ptr = std::unique_ptr<Message>(new ChatMessage(chat));
    msgs.Push(ptr);

    for (auto& user : _users)
        user->Deliver(msgs);
}

bool Netstream::write(const std::string &data)
{
	MessageBuffer msg;
	if (msg.set_body_length(data.size())) {
		memcpy(msg.body(), data.c_str(), data.size());
		boost::asio::async_write(sock_, boost::asio::buffer(msg.data(), msg.length()), boost::bind(&Netstream::handle_write, this, boost::asio::placeholders::error));
		return true;
	}
	return false;
}

void MuddComm::ProcessMessage(const TimeMessage& timeMsg)
{
    MessageBuffer msgs;
    auto now = time(0);
    auto s = ctime(&now);
    auto timeChat = std::unique_ptr<Message>(new ChatMessage(s));
    
    msgs.Push(timeChat);

    Deliver(msgs);
}

void SendQDirInfo()
{
	char cPacketID[2] = { VMPI_SHARED_PACKET_ID, VMPI_SUBPACKETID_DIRECTORIES };

	MessageBuffer mb;
	mb.write( cPacketID, 2 );
	mb.write( gamedir, strlen( gamedir ) + 1 );
	mb.write( qdir, strlen( qdir ) + 1 );

	VMPI_SendData( mb.data, mb.getLen(), VMPI_PERSISTENT );
}

void WorldSocket::Start()
{
    AsyncRead();

    MessageBuffer initializer;
    ServerPktHeader header(ServerConnectionInitialize.size(), 0);
    initializer.Write(header.header, header.getHeaderLength() - 2);
    initializer.Write(ServerConnectionInitialize.c_str(), ServerConnectionInitialize.length());

    std::unique_lock<std::mutex> dummy(_writeLock, std::defer_lock);
    QueuePacket(std::move(initializer), dummy);
}

void AuthSession::SendPacket(ByteBuffer& packet)
{
    if (!IsOpen())
        return;

    if (!packet.empty())
    {
        MessageBuffer buffer;
        buffer.Write(packet.contents(), packet.size());
        QueuePacket(std::move(buffer));
    }
}

bool ConnectionInstance::sendRaw(string& message) {
    if (closed)
        return false;

    MessageBuffer* buffer = new MessageBuffer();
    MessagePtr outMessage(buffer);
    buffer->Set(message.data(), message.length());

    writeQueue.push_back(outMessage);
    ev_io_start(loop, writeEvent);
    return true;
}

int DbWrapper::unlock()
{
    // no unlock for system db
    if (m_uid < 5000)
        return CKM_API_SUCCESS;

    int retCode;
    RawBuffer ret = m_logic.unlockUserKey(m_uid, m_pw);
    MessageBuffer buff;
    buff.Push(ret);
    buff.Deserialize(retCode);
    return retCode;
}