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 <Fw/FPrimeBasicTypes.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,      
        ALLOCATION_FAILED,  
        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;  // NO_CODESONAR (cpp:S3657)

    virtual Status create(FwEnumStoreType id,
                          const Fw::ConstStringBase& name,
                          FwSizeType depth,
                          FwSizeType messageSize) = 0;

    virtual void teardown() = 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(FwEnumStoreType id,
                  const Fw::ConstStringBase& name,
                  FwSizeType depth,
                  FwSizeType messageSize) override;

    void teardown() 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::LinearBufferBase& message, FwQueuePriorityType priority, BlockingType blockType);

    Status receive(Fw::LinearBufferBase& 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