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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 */
/********************************************************************
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library 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
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 *
 ********************************************************************/

/*
 * Desc: Message class and message queues
 * CVS:  $Id: message.h 9120 2013-01-07 00:18:52Z jpgr87 $
 * Author: Toby Collett - Jan 2005
 */

#ifndef MESSAGE_H
#define MESSAGE_H

#if defined (WIN32)
  #if defined (PLAYER_STATIC)
    #define PLAYERCORE_EXPORT
  #elif defined (playercore_EXPORTS)
    #define PLAYERCORE_EXPORT    __declspec (dllexport)
  #else
    #define PLAYERCORE_EXPORT    __declspec (dllimport)
  #endif
#else
  #define PLAYERCORE_EXPORT
#endif

#include <pthread.h>

#include <libplayerinterface/player.h>

class MessageQueue;

class PLAYERCORE_EXPORT QueuePointer
{
  public:
    QueuePointer();
    QueuePointer(bool _Replace, size_t _Maxlen);
        ~QueuePointer();
        QueuePointer(const QueuePointer & CopyFrom);
        
        QueuePointer & operator = (const QueuePointer & rhs);
        MessageQueue * operator -> ();
        MessageQueue * get() const;
        MessageQueue & operator * ();
        bool operator == (const QueuePointer & rhs);
        bool operator == (void * pointer);
        bool operator != (const QueuePointer & rhs);
        bool operator != (void * pointer);
        
  private:
    void DecRef();

    MessageQueue * Queue;

    unsigned int * RefCount;

    pthread_mutex_t * Lock;
};



class PLAYERCORE_EXPORT Message
{
  public:
    Message(const struct player_msghdr & Header,
            void* data,
            bool copy = true);

    Message(const struct player_msghdr & Header,
            void* data,
            QueuePointer &_queue,
            bool copy = true);

    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));
    }

    static bool MatchMessage(player_msghdr_t* hdr,
                             int type,
                             int subtype)
    {
      return(((type < 0) || (hdr->type == (uint8_t)type)) &&
             ((subtype < 0) || (hdr->subtype == (uint8_t)subtype)));
    }    
    
    player_msghdr_t * GetHeader() {return &Header;};
    void* GetPayload() {return (void*)Data;};
    unsigned int GetDataSize() {return Header.size;};
    bool Compare(Message &other);
    void DecRef();

    QueuePointer Queue;

    unsigned int * RefCount;

  private:
    void CreateMessage(const struct player_msghdr & Header,
            void* data,
            bool copy = true);
          
    player_msghdr_t Header;
    uint8_t * Data;
    pthread_mutex_t * Lock;
};

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

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

    friend class MessageQueue;
};

class PLAYERCORE_EXPORT 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, int _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 ==_interf && index == _index &&
          type == _type && subtype == _subtype);
    }

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

class PLAYERCORE_EXPORT MessageQueue
{
  public:
    MessageQueue(bool _Replace, size_t _Maxlen);
    ~MessageQueue();
    bool Empty() { return(this->head == NULL); }
    bool Push(Message& msg);

    void PushFront(Message & msg, bool haveLock);

    void PushBack(Message & msg, bool haveLock);

    Message* Pop();
    void SetReplace(bool _Replace) { this->Replace = _Replace; };
    void AddReplaceRule(int _host, int _robot, int _interf, int _index,
                        int _type, int _subtype, int _replace);
    void AddReplaceRule(const player_devaddr_t &device,
                        int _type, int _subtype, int _replace);
    int CheckReplace(player_msghdr_t* hdr);
    bool Wait(double TimeOut=0.0);
    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; }

    size_t GetLength(void);

    void SetDataRequested(bool d, bool haveLock);

  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;
    bool data_requested;
    bool data_delivered;
    bool drop_count;
};




#endif