Tools/MessageQueue/MessageQueue.cpp

Go to the documentation of this file.

/**
* @file MessageQueue.cpp
*
* Implementation of class MessageQueue and helper classes
* 
* @author Martin Lötzsch
*/

#include "MessageQueue.h"
#include "Platform/GTAssert.h"

MessageQueue::MessageQueue()
: in(queue), out(queue)
{
  ASSERT(idJPEGImage == 37); // otherwise log files will not work anymore
}

void MessageQueue::setSize(int size)
{
  queue.setSize(size);
}

void MessageQueue::setPlayerForNewMessages(const Player& player)
{
  out.teamColorForNewMessages = player.getTeamColor();
  out.playerNumberForNewMessages = player.getPlayerNumber();
}

void MessageQueue::handleSpecificMessages(MessageID id, MessageHandler& handler)
{
  for (int i=0; i<queue.getNumberOfMessages(); i++)
  {
    queue.setSelectedMessageForReading(i);
    if (in.getMessageID()==id)
    {
      in.config.reset();
      in.text.reset();
      handler.handleMessage(in);
    }
  }
}

void MessageQueue::handleAllMessages(MessageHandler& handler)
{
  for (int i=0; i<queue.getNumberOfMessages(); i++)
  {
    queue.setSelectedMessageForReading(i);
    in.config.reset();
    in.text.reset();
    handler.handleMessage(in);
  }
}

void MessageQueue::copyAllMessages(MessageQueue& other)
{
  for (int i=0; i<queue.getNumberOfMessages(); i++)
  {
    copyMessage(i,other);
  }
}

void MessageQueue::moveAllMessages(MessageQueue& other)
{
  copyAllMessages(other);
  clear();
}

void MessageQueue::clear()
{
  queue.clear();
}

bool MessageQueue::isEmpty() const
{
  return queue.getNumberOfMessages() == 0;
}

void MessageQueue::copyMessage(int message, MessageQueue& other)
{
  queue.setSelectedMessageForReading(message);
  other.out.bin.write(queue.getData(),queue.getMessageSize());
  other.out.finishMessage(
    queue.getMessageID(),
    queue.getTimeStamp(),
    queue.getTeamColor(),
    queue.getPlayerNumber(),
    queue.getMessageWasSentFromAPhysicalRobot());
}

//
// Format of a message in a log file:
//
// byte
// 0     Bit 0: if 1, then this is the last message in the queue
//       Bit 1-2: the team color. 0:undef, 1: red, 2:blue, 3:undef
//       Bit 2-5: the player number: 0:undef, 1:0, 2:1, 3:2, 4:3, 5:undef
//       Bit 6  : where the message is from: 0:physical robot, 1:simulated robot
// 1-4   Size of the message (without header) in bytes
// 5     id of the message
// 6-9  timestamp
// 10-?  content
//

In& operator>>(In& stream,MessageQueue& messageQueue)
{
  unsigned int messageSize;
  char id,c;
  unsigned long timeStamp;
  bool last=false;
  char buffer[100000];
  while (!last)
  {
    stream >> c >> messageSize >> id >> timeStamp;
    ASSERT(messageSize<10*1024*1024);
    while(messageSize > 0)
    {
      unsigned int blockSize = messageSize > sizeof(buffer) ? sizeof(buffer) : messageSize;
      stream.read(buffer,blockSize); 
      messageQueue.out.bin.write(buffer,blockSize);
      messageSize -= blockSize;
    }

    // This might look strange but is needed for compability with old log files
    last = (c%2==1);
    messageQueue.out.finishMessage((MessageID)id,timeStamp,
      ((c>>1)%4==0? Player::undefinedTeamColor : (Player::teamColor)(((c>>1)%4)-1)),
      ((c>>3)%8==0? Player::undefinedPlayerNumber : (Player::playerNumber)(((c>>3)%8)-1)),
      (c>>6)==0);

#ifdef _WIN32
    //its only the last message, if message marker *and* stream claim that
    //this way we can read appended log files *and* find last message in memory
    last &= stream.eof();
    //this only works on PC, because on robots memory of known size (different
    //from length of messages in it) is used in Receiver
#endif
  }
  return stream;
}

int MessageQueue::getStreamedSize()
{
  int size = 0;

  for (int i=0; i< queue.getNumberOfMessages(); i++)
  {
    queue.setSelectedMessageForReading(i);
    size += in.getMessageSize() + 10;
  }
  return size;
}

Out& operator<<(Out& stream, const MessageQueue& messageQueue)
{
  for (int i=0; i< messageQueue.queue.getNumberOfMessages(); i++)
  {
    // check if the message is the last streamed message
    bool last = (i == messageQueue.queue.getNumberOfMessages()-1);

    ((MessageQueue&)messageQueue).queue.setSelectedMessageForReading(i);

    // This might look strange but is needed for compability with old log files
    char c = (char)(last)
      + (((char)messageQueue.in.getTeamColor()+1) << 1)
      + (((char)messageQueue.in.getPlayerNumber()+1) << 3)
      + (((char)!messageQueue.in.getMessageWasSentFromAPhysicalRobot()) << 6);

    // write message parameters to the stream
    stream << c
      << messageQueue.in.getMessageSize() 
      << (char)messageQueue.in.getMessageID()
      << messageQueue.in.getTimeStamp();

    // write message content
    stream.write(messageQueue.in.getData(),messageQueue.in.getMessageSize());
  }
  return stream;
}

void operator >> (InMessage& message, MessageQueue& queue)
{
  queue.out.bin.write(message.getData(),message.getMessageSize());
  queue.out.finishMessage(message.getMessageID(),
    message.getTimeStamp(),
    message.getTeamColor(),
    message.getPlayerNumber(),
    message.getMessageWasSentFromAPhysicalRobot());
}

---