TaskQueue.h

/*
** libutil++
** $Id: TaskQueue.h 1653 2016-02-28 19:54:59Z sella $
** Copyright (c) 2011-2016 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__util__TaskQueue_H__
#define __libutilxx__sella__util__TaskQueue_H__

#include "../../common.h"
#include "Task.h"
#include "Log.h"

#include <vector>
#include <chrono>

namespace sella {
        namespace util {
                class TaskQueue;
                static const timeval FallbackTimeval = { 0, 200000 }; /* 200ms */
        }
}

class sella::util::TaskQueue { /* NOTE: TaskQueue is not natively thread safe. Add your own locking if needed. */
        public:
                typedef std::shared_ptr<TaskQueue> shared;

        public:
                static const size_t DefaultMinimumCapacity = 16;

                static const uint64_t FallbackMsecDelay = 200;
                static const uint64_t FallbackUsecDelay = 200000;

        public:
                TaskQueue(const size_t capacity = DefaultMinimumCapacity);
                TaskQueue(Log::shared log, const size_t capacity = DefaultMinimumCapacity);
                TaskQueue(const TaskQueue &other) = delete;
                virtual ~TaskQueue();
                TaskQueue& operator=(const TaskQueue &other) = delete;

                size_t size(void) const;
                bool empty(void) const;
                void clear(void);

                Task::shared top(void) const;
                Task::shared next(void) const;

                const timeval getDelay(timeval fallback = FallbackTimeval) const;
                uint64_t getDelayMsec(uint64_t fallback = FallbackMsecDelay, uint64_t maximum = 0) const;
                uint64_t getDelayUsec(uint64_t fallback = FallbackUsecDelay, uint64_t maximum = 0) const;

                void push(Task::shared &task);
                void push(Task::shared &task, const std::chrono::system_clock::duration &delay, int priority = 0);
                void push(Task::shared &task, const std::chrono::system_clock::time_point &time, int priority = 0);
                void push(Task::shared &task, time_t sec, suseconds_t usec = 0, int priority = 0);
                void push(Task::shared &task, timeval &tv, int priority = 0);
                bool repush(Task::shared &task, const std::chrono::system_clock::duration &delay, int priority = 0, bool strict = false);
                bool repush(Task::shared &task, const std::chrono::system_clock::time_point &time, int priority = 0, bool strict = false);
                bool repush(Task::shared &task, time_t sec, suseconds_t usec = 0, int priority = 0, bool strict = false);
                bool repush(Task::shared &task, timeval &tv, int priority = 0, bool strict = false);
                void pop(void);
                bool erase(Task::shared &task, bool firstonly = true);
                bool erase(void *object);

                size_t capacity(void) const;
                void reserve(size_t capacity);
                void print(void) const;
                void setLog(Log::shared log);

                bool isReady(void) const;

        protected:
                Log::shared libutilxx__log;
                std::vector<Task::shared> heap;
};

#endif

/*
** vim: noet ts=3 sw=3
*/