Player

• Frontpage
• Contents

User

• Installation
• Quick start
• Supported devices
• Tutorials
• Utilities
• Client libraries
• FAQ
• Help

Developer

• Architecture
• libplayercore
  • interfaces
• libplayerdrivers
  • drivers
• libplayererror
• libplayertcp
• libplayerxdr
• TODO

Online

Homepage
Download
Project
Bugs
Help

message.h

/*
 *  Player - One Hell of a Robot Server
 *  Copyright (C) 2000
 *     Brian Gerkey, Kasper Stoy, Richard Vaughan, & Andrew Howard
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */
/*
 * Desc: Message class and message queues
 * CVS:  $Id: message.h,v 1.16 2006/03/17 21:22:05 gerkey Exp $
 * Author: Toby Collett - Jan 2005
 */

#ifndef MESSAGE_H
#define MESSAGE_H

#include <pthread.h>

#include <libplayercore/player.h>

// TODO:
//   - Add support for stealing the data pointer when creating a message.
//     That would save one allocation & copy in some situations.

class MessageQueue;

class Message
{
  public:
    Message(const struct player_msghdr & Header,
            const void* data,
            unsigned int data_size,
            MessageQueue* _queue = NULL);
    Message(const Message & rhs);

    ~Message();

    static bool MatchMessage(player_msghdr_t* hdr,
                             int type,
                             int subtype,
                             player_devaddr_t addr)
    {
      return(((type < 0) || (hdr->type == (uint8_t)type)) &&
             ((subtype < 0) || (hdr->subtype == (uint8_t)subtype)) &&
             (hdr->addr.host == addr.host) &&
             (hdr->addr.robot == addr.robot) &&
             (hdr->addr.interf == addr.interf) &&
             (hdr->addr.index == addr.index));
    }

    void* GetData() {return (void*)Data;};
    player_msghdr_t * GetHeader() {return reinterpret_cast<player_msghdr_t *> (Data);};
    void* GetPayload() {return (void*)(&Data[sizeof(player_msghdr_t)]);};
    size_t GetPayloadSize() {return Size - sizeof(player_msghdr_t);};
    unsigned int GetSize() {return Size;};
    bool Compare(Message &other);
    void DecRef();
    void SetReady ()            { ready = true; }
                bool Ready (void) const     { return ready; }

    MessageQueue* Queue;

    unsigned int * RefCount;

  private:
    uint8_t * Data;
    unsigned int Size;
    pthread_mutex_t * Lock;
    bool ready;
};

class MessageQueueElement
{
  public:
    MessageQueueElement();
    ~MessageQueueElement();

    Message* msg;
  private:
    MessageQueueElement * prev;
    MessageQueueElement * next;

    friend class MessageQueue;
};

class MessageReplaceRule
{
  private:
    // The address to match (not using a player_devaddr_t so that we can
    // use -1 to indicate don't care)
    int host, robot, interf, index;
    // The type and subtype to match (-1 is don't care)
    int type, subtype;
  public:
    MessageReplaceRule(int _host, int _robot, int _interf, int _index,
                       int _type, int _subtype, bool _replace) :
            host(_host), robot(_robot), interf(_interf), index(_index),
            type(_type), subtype(_subtype), replace(_replace), next(NULL) {}

    bool Match(player_msghdr_t* hdr)
    {
      return(((this->host < 0) ||
              ((uint32_t)this->host == hdr->addr.host)) &&
             ((this->robot < 0) ||
              ((uint32_t)this->robot == hdr->addr.robot)) &&
             ((this->interf < 0) ||
              ((uint16_t)this->interf == hdr->addr.interf)) &&
             ((this->index < 0) ||
              ((uint16_t)this->index == hdr->addr.index)) &&
             ((this->type < 0) ||
              ((uint8_t)this->type == hdr->type)) &&
             ((this->subtype < 0) ||
              ((uint8_t)this->subtype == hdr->subtype)));
    }

    bool Equivalent (int _host, int _robot, int _interf, int _index, int _type, int _subtype)
    {
      return (host == _host && robot == _robot && _interf && index == _index &&
          type == _type && subtype == _subtype);
    }

    // To replace, or not to replace
    // That is the question
    bool replace;
    // Next rule in the list
    MessageReplaceRule* next;
};

class MessageQueue
{
  public:
    MessageQueue(bool _Replace, size_t _Maxlen);
    ~MessageQueue();
    bool Empty() { return(this->head == NULL); }
    MessageQueueElement * Push(Message& msg, bool UseReserved = false);
    Message* Pop();
    Message* PopReady (void);
    void SetReplace(bool _Replace) { this->Replace = _Replace; };
    void AddReplaceRule(int _host, int _robot, int _interf, int _index,
                        int _type, int _subtype, bool _replace);
    void AddReplaceRule(const player_devaddr_t &device,
                        int _type, int _subtype, bool _replace);
    bool CheckReplace(player_msghdr_t* hdr);
    void Wait(void);
    void DataAvailable(void);
    bool Filter(Message& msg);
    void ClearFilter(void);
    void SetFilter(int host, int robot, int interf, int index,
                   int type, int subtype);
    void SetPull (bool _pull) { this->pull = _pull; }
    void MarkAllReady (void);
    
    size_t GetLength(void);
  private:
    void Lock() {pthread_mutex_lock(&lock);};
    void Unlock() {pthread_mutex_unlock(&lock);};
    void Remove(MessageQueueElement* el);
    MessageQueueElement* head;
    MessageQueueElement* tail;
    pthread_mutex_t lock;
    size_t Maxlen;
    MessageReplaceRule* replaceRules;
    bool Replace;
    size_t Length;
    pthread_cond_t cond;
    pthread_mutex_t condMutex;
    bool filter_on;
    int filter_host, filter_robot, filter_interf,
        filter_index, filter_type, filter_subtype;
    bool pull;
};

#endif

---

Last updated 12 September 2005 21:38:45