Queue.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/Queue.hpp
// \brief common function definitions for Os::Queue
// ======================================================================
#ifndef Os_Queue_hpp_
#define Os_Queue_hpp_
 
#include <FpConfig.hpp>
#include <Fw/Obj/ObjBase.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Os/Os.hpp>
#include <Os/QueueString.hpp>
#include <Os/Mutex.hpp>
namespace Os {
// Forward declaration for registry
class QueueRegistry;
 
class QueueHandle {};
 
class QueueInterface {
  public:
    enum Status {
        OP_OK,             
        ALREADY_CREATED,   
        EMPTY,             
        UNINITIALIZED,     
        SIZE_MISMATCH,     
        SEND_ERROR,        
        RECEIVE_ERROR,     
        INVALID_PRIORITY,  
        FULL,              
        UNKNOWN_ERROR      
    };
 
    enum BlockingType {
        BLOCKING,    
        NONBLOCKING  
    };
 
    QueueInterface() = default;
 
    virtual ~QueueInterface() = default;
 
    QueueInterface(const QueueInterface& other) = delete;
 
    QueueInterface(const QueueInterface* other) = delete;
 
    virtual QueueInterface& operator=(const QueueInterface& other) = delete;
 
    virtual Status create(const Fw::StringBase& name, FwSizeType depth, FwSizeType messageSize) = 0;
 
    virtual Status send(const U8* buffer, FwSizeType size, FwQueuePriorityType priority, BlockingType blockType) = 0;
 
    virtual Status receive(U8* destination,
                           FwSizeType capacity,
                           BlockingType blockType,
                           FwSizeType& actualSize,
                           FwQueuePriorityType& priority) = 0;
 
    virtual FwSizeType getMessagesAvailable() const = 0;
 
    virtual FwSizeType getMessageHighWaterMark() const = 0;
 
    virtual QueueHandle* getHandle() = 0;
 
    static QueueInterface* getDelegate(QueueHandleStorage& aligned_placement_new_memory);
};
 
class Queue final : public QueueInterface {
  public:
    Queue();
 
    virtual ~Queue();
 
    Queue(const Queue& other) = delete;
 
    Queue(const Queue* other) = delete;
 
    QueueInterface& operator=(const QueueInterface& other) override = delete;
 
    Status create(const Fw::StringBase& name, FwSizeType depth, FwSizeType messageSize) override;
 
    Status send(const U8* buffer, FwSizeType size, FwQueuePriorityType priority, BlockingType blockType) override;
 
    Status receive(U8* destination,
                   FwSizeType capacity,
                   BlockingType blockType,
                   FwSizeType& actualSize,
                   FwQueuePriorityType& priority) override;
 
    FwSizeType getMessagesAvailable() const override;
 
    FwSizeType getMessageHighWaterMark() const override;
 
    QueueHandle* getHandle() override;
 
    Status send(const Fw::SerializeBufferBase& message, FwQueuePriorityType priority, BlockingType blockType);
 
    Status receive(Fw::SerializeBufferBase& destination, BlockingType blockType, FwQueuePriorityType& priority);
 
    FwSizeType getDepth() const;
 
    FwSizeType getMessageSize() const;
 
    const QueueString& getName() const;
 
    static FwSizeType getNumQueues();
 
    static Os::Mutex& getStaticMutex();
 
  private:
    QueueString m_name;                           
    FwSizeType m_depth;                           
    FwSizeType m_size;                            
    static Os::Mutex s_countLock;                 
    static FwSizeType s_queueCount;               
 
#if FW_QUEUE_REGISTRATION
  public:
    static void setRegistry(QueueRegistry* registry);
 
  private:
    static QueueRegistry* s_queueRegistry;  
#endif
 
    // This section is used to store the implementation-defined file handle. To Os::File and fprime, this type is
    // opaque and thus normal allocation cannot be done. Instead, we allow the implementor to store then handle in
    // the byte-array here and set `handle` to that address for storage.
    //
    alignas(FW_HANDLE_ALIGNMENT) QueueHandleStorage m_handle_storage;  
    QueueInterface& m_delegate;                                        
};
class QueueRegistry {
  public:
    QueueRegistry() = default;
    virtual ~QueueRegistry() = default;
 
    virtual void registerQueue(Queue* queue) = 0;  
};
}  // namespace Os
#endif