/builddir/build/BUILD/libutil++-1.4.0/src/sella/util/Task.h

/*
** libutil++
** $Id: Task.h 1230 2014-11-16 02:32:01Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

#ifndef __libutilxx__sella__util__Task_H__
#define __libutilxx__sella__util__Task_H__

#include "../../common.h"

#include <sys/time.h>
#include <stdexcept>

#include <string>
#include <memory>
#include <vector>
#include <chrono>
#include <functional>

#define SELLA_UTIL_TASK_DELAY_SEC_DEF 1
#define SELLA_UTIL_TASK_DELAY_USEC_DEF 500000

namespace sella {
        namespace util {
                class Task;
                static const timeval delay_def = { SELLA_UTIL_TASK_DELAY_SEC_DEF, SELLA_UTIL_TASK_DELAY_USEC_DEF };
                static const timeval notset = { 0, 0 };
        }
}

class sella::util::Task {
        public:
                typedef std::shared_ptr<Task> shared;
                typedef Task *ptr;
                typedef std::function<void(void)> callback;

                typedef struct {
                        size_t operator()(const shared &a) const {
                                return (size_t) a.get();
                        }
                } shared_hash;
        public:
                Task();
                Task(Task::callback &callback, void* object = NULL, int priority = 0);
                Task(const Task &other);
                Task(const Task &&other);
                virtual ~Task();
                Task& operator=(const Task &other);
                Task& operator=(const Task &&other);

                void clear(void);

                Task& setTimer(const std::chrono::system_clock::time_point &time);
                Task& setTimer(timeval &timer);
                Task& setTimer(time_t &timer);
                Task& setDelay(const std::chrono::system_clock::duration &duration);
                Task& setDelay(time_t sec = 0, suseconds_t usec = 0);
                Task& setNoDelay(void); /* Possible to starve task queue. */
                Task& setPriority(int priority); /* Higher is better */
                Task& setCallback(Task::callback &callback, void *object = NULL);
                Task& setObject(void *object);
                Task& setData(std::vector<void*> &data);
                Task& addData(void *data);

                const timeval& getTimer(void) const;
                const timeval getDelay(void) const;
                int getPriority(void) const;
                const Task::callback& getCallback(void) const;
                void* getObject(void) const;
                std::vector<void*> getData(void) const;
                void* getData(size_t pos) const throw (std::out_of_range);

                void execute(void);

                static const Task::shared shared_ptr(void) throw ();
                static const Task::shared shared_ptr(Task::callback &callback, void *object = NULL, int priority = 0);

                static const timeval getDelay(const shared task, const timeval def = delay_def);
                static bool compareTimer(const shared task, const timeval now = notset);

        protected:
                timeval timer;
                int priority;

                callback function;
                void *object;
                std::vector<void*> data;

        private:
};

#endif

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

---