Task.cpp

/*
** libutil++
** $Id: Task.cpp 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
*/

static const char rcsid[] __attribute__((used)) = "$Id: Task.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "Task.h"
#include "Time.h"

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>

using namespace sella::util;

Task::Task() : timer({0, 0}), priority(0), function(NULL), object(NULL) {
        timerclear(&timer);
}

Task::Task(Task::callback &callback, void *object, int priority) :
        timer({ 0, 0 }),
        priority(priority),
        function(callback),
        object(object)
{
        timerclear(&timer);
}

Task::Task(const Task &other) :
        timer(other.timer),
        priority(other.priority),
        function(other.function),
        object(other.object),
        data(other.data)
{ }

Task::Task(const Task &&other) :
        timer(other.timer),
        priority(other.priority),
        function(std::move(other.function)),
        object(other.object),
        data(other.data)
{ }

Task::~Task() {
        function = NULL;
}

Task& Task::operator=(const Task &other) {
        if (this != &other) {
                this->timer = other.timer;
                this->priority = other.priority;
                this->function = other.function;
                this->object = other.object;
                this->data = other.data;
        }

        return *this;
}

Task& Task::operator=(const Task &&other) {
        if (this != &other) {
                this->timer = other.timer;
                this->priority = other.priority;
                this->function = std::move(other.function);
                this->object = other.object;
                this->data = other.data;
        }

        return *this;
}

void Task::clear(void) {
        timerclear(&timer);
        priority = 0;
        function = NULL;
        object = NULL;
        data.clear();
}

Task& Task::setTimer(const std::chrono::system_clock::time_point &time) {
        this->timer = Time::chronototv(time);

        return *this;
}

Task& Task::setTimer(timeval &timer) {
        this->timer = timer;

        return *this;
}

Task& Task::setTimer(time_t &timer) {
        this->timer = Time::sectotv(timer);

        return *this;
}

Task& Task::setDelay(const std::chrono::system_clock::duration &duration) {
        timeval now = { 0, 0 }, delay = Time::chronototv(duration);

        if (gettimeofday(&now, NULL) == 0) {
                timeradd(&now, &delay, &(this->timer));
        }

        return *this;
}

Task& Task::setDelay(time_t sec, suseconds_t usec) {
        timeval now = { 0, 0 }, delay = { sec + usec / 1000000, usec % 1000000 };

        if (gettimeofday(&now, NULL) == 0) {
                timeradd(&now, &delay, &(this->timer));
        }

        return *this;
}

Task& Task::setNoDelay(void) {
        timerclear(&(this->timer));

        return *this;
}

Task& Task::setPriority(int priority) {
        this->priority = priority;

        return *this;
}

Task& Task::setCallback(callback &function, void *object) {
        this->function = function;
        this->object = object;
        this->data = data;

        return *this;
}

Task& Task::setObject(void *object) {
        this->object = object;

        return *this;
}

Task& Task::setData(std::vector<void*> &data) {
        this->data = data;

        return *this;
}

Task& Task::addData(void *data) {
        this->data.push_back(data);

        return *this;
}

const timeval& Task::getTimer(void) const {
        return timer;
}

const timeval Task::getDelay(void) const {
        static const timeval zero = { 0, 0 };
        timeval delay = { 0, 0 };

        if (gettimeofday(&delay, NULL) == 0) {
                if (timercmp(&delay, &(this->timer), <)) {
                        timersub(&timer, &delay, &delay);

                        if (timercmp(&delay, &zero, <)) {
                                timerclear(&delay);
                        }
                } else {
                        timerclear(&delay);
                }
        }

        return delay;
}

uint64_t Task::getDelayMsec(void) const {
        return Time::tvtomsec(getDelay());
}

uint64_t Task::getDelayUsec(void) const {
        return Time::tvtousec(getDelay());
}

int Task::getPriority(void) const {
        return priority;
}

const Task::callback& Task::getCallback(void) const {
        return function;
}

void* Task::getObject(void) const {
        return object;
}

std::vector<void*> Task::getData(void) const {
        return data;
}

void* Task::getData(size_t pos) const throw (std::out_of_range) {
        return data.at(pos);
}

bool Task::isReady(void) const {
        timeval now;

        gettimeofday(&now, NULL);

        if (timercmp(&now, &timer, >=)) {
                return true;
        }

        return false;
}

void Task::execute(void) {
        if (function) {
                function();
        }
}

const Task::shared Task::shared_ptr(void) throw () {
        return std::make_shared<Task>();
}

const Task::shared Task::shared_ptr(Task::callback &callback, void *object, int priority) {
        return std::make_shared<Task>(callback, object, priority);
}

const timeval Task::getDelay(const shared task, timeval delay) {
        if (task) {
                return task->getDelay();
        }

        return delay;
}

bool Task::compareTimer(const shared task, timeval now) {
        if (task) {
                timeval timer = task->getTimer();

                if (!timerisset(&now)) {
                        gettimeofday(&now, NULL);
                }

                if (timercmp(&now, &timer, >=)) {
                        return true;
                }
        }

        return false;
}

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