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/Mutex.hpp>
#include <Os/Os.hpp>
#include <Os/QueueString.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,              
        NOT_SUPPORTED,     
        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