Queue.h

Go to the documentation of this file.

 
// ###########################################################################################################################################################################################################################################################################################################################
 
#pragma once
 
// OpenTwin header
#include "OTCore/CoreAPIExport.h"
#include "OTCore/Flags.h"
 
// std header
#include <list>
 
#pragma warning (disable:4251)
 
namespace ot {
 
    class __declspec(dllexport) QueueDestroyableObject {
    public:
        enum CleanupFlag {
            DeleteAtEnd = 0x00, 
            DeleteAfter = 0x01, 
            NoDelete    = 0x03, 
            Multiuse    = 0x04  
        };
        typedef Flags<CleanupFlag> CleanupFlags;
                
        QueueDestroyableObject() : m_cleanupFlags(DeleteAtEnd) {};
        QueueDestroyableObject(CleanupFlag _cleanupFlags) : m_cleanupFlags(_cleanupFlags) {};
        virtual ~QueueDestroyableObject() {};
 
        void setCleanupFlag(CleanupFlag _flag, bool _active = true) { m_cleanupFlags.setFlag(_flag, _active); };
        void setCleanupFlags(const CleanupFlags& _flags) { m_cleanupFlags = _flags; };
        const CleanupFlags& cleanupFlags(void) const { return m_cleanupFlags; };
 
    private:
        CleanupFlags m_cleanupFlags;
 
        QueueDestroyableObject(const QueueDestroyableObject&) = delete;
        QueueDestroyableObject& operator = (const QueueDestroyableObject&) = delete;
    };
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    class __declspec(dllexport) QueueData :  public QueueDestroyableObject {
    public:
        QueueData(CleanupFlag _cleanupFlags = DeleteAtEnd) : QueueDestroyableObject(_cleanupFlags) {};
        virtual ~QueueData() {};
 
    private:
        
        QueueData(const QueueData&) = delete;
        QueueData& operator = (const QueueData&) = delete;
    };
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    class AbstractQueue;
 
    class __declspec(dllexport) QueueObject : public QueueDestroyableObject {
    public:
        enum QueueResultFlag {
            Ok          = 0x00, 
            JobFailed   = 0x01, 
            Requeue     = 0x02, 
            CancelQueue = 0x04, 
            FinishQueue = 0x08  
        };
        typedef ot::Flags<QueueObject::QueueResultFlag> QueueResultFlags;
 
        QueueObject(CleanupFlag _cleanupFlags = DeleteAtEnd) : QueueDestroyableObject(_cleanupFlags) {};
        virtual ~QueueObject() {};
 
        virtual QueueResultFlags activateFromQueue(AbstractQueue* _queue, QueueData* _args) = 0;
 
    private:
        QueueObject(const QueueObject&) = delete;
        QueueObject& operator = (const QueueObject&) = delete;
    };
}
 
OT_ADD_FLAG_FUNCTIONS(ot::QueueDestroyableObject::CleanupFlag)
OT_ADD_FLAG_FUNCTIONS(ot::QueueObject::QueueResultFlag)
 
namespace ot {  
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    class __declspec(dllexport) AbstractQueue {
    public:
        AbstractQueue() {};
        virtual ~AbstractQueue() {};
 
        virtual void queue(QueueObject* _obj, QueueData * _args = (QueueData *)nullptr) noexcept = 0;
 
        virtual void queueNext(QueueObject* _obj, QueueData* _args = (QueueData*)nullptr) noexcept = 0;
 
        virtual bool executeQueue(void) = 0;
 
    private:
        AbstractQueue(const AbstractQueue&) = delete;
        AbstractQueue& operator = (const AbstractQueue&) = delete;
    };
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    // ###########################################################################################################################################################################################################################################################################################################################
 
    class OT_CORE_API_EXPORT SimpleQueue : public AbstractQueue {
    public:
        SimpleQueue();
        virtual ~SimpleQueue();
 
        virtual void queue(QueueObject* _obj, QueueData* _arg = (QueueData*)nullptr) noexcept override;
 
        virtual void queueNext(QueueObject* _obj, QueueData* _arg = (QueueData*)nullptr) noexcept override;
 
        virtual bool executeQueue(void) override;
 
        void clearQueue(void);
 
    protected:
 
        void checkAndDestroy(QueueDestroyableObject* _obj);
 
    private:
        void clearGarbage(void);
 
        std::list<std::pair<QueueObject*, QueueData*>> m_queue;
        std::list<std::pair<QueueDestroyableObject*, bool>> m_garbage;
        unsigned int m_garbageCounter;
 
        SimpleQueue(const SimpleQueue&) = delete;
        SimpleQueue& operator = (const SimpleQueue&) = delete;
    };
 
}