msgqueuebase.h

Go to the documentation of this file.

/*
 *   Copyright 2014-2015 The 4S Foundation (www.4s-online.dk)
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

#ifndef MSGQUEUEBASE_H
#define MSGQUEUEBASE_H

#include "FSYS/handle.h"
#include "FSYS/msgcallback.h"
#include "FSYS/msgaddr.h"

#include <condition_variable>
#include <forward_list>
#include <memory>
#include <mutex>
#include <queue>
#include <typeinfo>

namespace FSYS
{
  class MsgSenderBase;

  class MsgQueueBase: public Handle
  {
  friend class MsgSenderBase;
  private:
    explicit MsgQueueBase();
    ~MsgQueueBase();

    class ListenerListItem
    {
    public:
      void *magicKey;
      const std::type_info &typeOfMsg;
      MsgCallBack * msgCallBack;
      ListenerListItem( void *magicKey,
                        const std::type_info &typeOfMsg,
                        MsgCallBack * msgCallBack)
        : magicKey(magicKey),
          typeOfMsg(typeOfMsg),
          msgCallBack(msgCallBack)
      {}
    };

    class MsgQueueItem
    {
    public:
      std::shared_ptr<BaseMsg> msg;  // Msg to queue
      const std::type_info &typeOfMsg;
      Handle object;                 // Msg object to target
      void *magicKey;                   // MagicKey to target
      MsgQueueItem(std::shared_ptr<BaseMsg> msg,
                   const std::type_info &typeOfMsg,
                   Handle object,
                   void *magicKey)
        : msg(msg),
          typeOfMsg(typeOfMsg),
          object(object),
          magicKey(magicKey)
      {}

      MsgQueueItem(const MsgQueueItem &msgQueueItem)
        : msg(msgQueueItem.msg),
          typeOfMsg(msgQueueItem.typeOfMsg),
          object(msgQueueItem.object),
          magicKey(msgQueueItem.magicKey)
      {}
    };

    std::condition_variable_any localQueueConditionVariable;
    std::queue<MsgQueueItem> localMsgQueue;

    inline static std::recursive_mutex &getMutex( void )
    {
      static std::recursive_mutex mutex;
      return mutex;
    }

    std::forward_list<ListenerListItem> localListenerList;

    // The list of queues in the system
    static std::forward_list<MsgQueueBase*> listOfQueues;

    static void sendMsg(std::shared_ptr<BaseMsg> msg,  // Msg to send
                        const std::type_info &typeOfMsg,  // Type of msg to send                        
                        Handle queue,                     // Msg queue to target
                        Handle object,                    // Msg object to target
                        void *magicKey                    // MagicKey to target
                       );




    inline static MsgQueueBase &getThreadQueue( void )
    {
      static thread_local MsgQueueBase localQueue;
      return localQueue;
    }


    inline static bool &getTerminateLoopFlag( void )
    {
      // Set to true when loop should be terminated
      static thread_local bool terminateFlag;

      return terminateFlag;
    }

  public:

    inline static Handle getBroadCastHandle( void )
    {
      static Handle broadcastHandle;
      return broadcastHandle;
    }


    static void addListenerToQueue(void *magicKey,
                                   const std::type_info &typeOfMsg,
                                   MsgCallBack *msgCallBack);

    static void removeListenerFromQueue(MsgCallBack *msgCallBack);



    static void waitUntilQueueHasData( void );

    static void emptyMsgQueue( int maxTimeMs=-1 );



    static void breakEmptyMsgQueue( void );

    static bool isEmpty( void );

    inline static Handle getHandle( void )
    {
      return getThreadQueue();
    }

  };

}

#endif // MSGQUEUEBASE_H