task.cpp

Go to the documentation of this file.

// PTF - Psychological Test Framework
// http://ptf.sourceforge.net
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Library General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

#include <ptf/core/task.hpp>

Task::Task() {
    id = 0;
    setReactionWindow(0, 0, 2, 0);
    setWaitPrepareExecute(2, 0);
    setWaitExecuteFinish(2, 0);
    setWaitFinishNextTask(2, 0);
}

Task::Task(int taskId, const timespec& prepExeWait, const timespec& exeFinWait, 
           const timespec& finNextWait, const TimeInterval& window) {
        id = taskId;
        setWaitPrepareExecute(prepExeWait);
        setWaitExecuteFinish(exeFinWait);
        setWaitFinishNextTask(finNextWait);
        timespec a, b;
        window.getInterval(a, b);
        reactionWindow.setInterval(a, b);                          
}

Task::Task(int taskId, long int prepExeWaitSec, long int prepExeWaitNano, 
           long int exeFinWaitSec, long int exeFinWaitNano, 
           long int finNextWaitSec, long int finNextWaitNano,
                   long int windowStartSec, long int windowStartNano, 
           long int windowEndSec, long int windowEndNano) {
        id = taskId;
        setWaitPrepareExecute(prepExeWaitSec, prepExeWaitNano);
        setWaitExecuteFinish(exeFinWaitSec, exeFinWaitNano);
        setWaitFinishNextTask(finNextWaitSec, finNextWaitNano);                    
        setReactionWindow(windowStartSec, windowStartNano, 
                                  windowEndSec, windowEndNano);                    
}

Task::Task(const Task& task) {
    id = task.id;
    reactionWindow = task.reactionWindow;
    waitPrepareExecute = task.waitPrepareExecute;
    waitExecuteFinish = task.waitExecuteFinish;
    waitFinishNextTask = task.waitFinishNextTask;
}

Task::~Task() {
    // nothing to do here
}

int Task::getId() const {
    return id;
}

timespec Task::getWaitPrepareExecute() const  {
    return waitPrepareExecute;
}

timespec Task::getWaitExecuteFinish() const  {
    return waitExecuteFinish;
}

timespec Task::getWaitFinishNextTask() const  {
    return waitFinishNextTask;
}

const TimeInterval& Task::getReactionWindow() const  {
    return reactionWindow;
}

const vector<bool>& Task::getSuccessfulReaction() const {
    return successfulReaction;
}

void Task::setReactionWindow(long int s1, long int ns1, long int s2, long int ns2) {
    timespec a, b;
    a.tv_sec = s1; a.tv_nsec = ns1;
    b.tv_sec = s2; b.tv_nsec = ns2;
    reactionWindow.setInterval(a, b);
}

void Task::setReactionWindow(const timespec& a, const timespec& b) {
    reactionWindow.setInterval(a, b);
}

void Task::setReactionWindow(const TimeInterval& time) {
    reactionWindow = time;
}

void Task::setWaitPrepareExecute(long int s, long int ns) {
    waitPrepareExecute.tv_sec  = s;
    waitPrepareExecute.tv_nsec = ns;
}

void Task::setWaitExecuteFinish(long int s, long int ns) {
    waitExecuteFinish.tv_sec  = s;
    waitExecuteFinish.tv_nsec = ns;
}

void Task::setWaitFinishNextTask(long int s, long int ns) {
    waitFinishNextTask.tv_sec  = s;
    waitFinishNextTask.tv_nsec = ns;
}

void Task::setWaitPrepareExecute(const timespec& time) {
    waitPrepareExecute.tv_sec  = time.tv_sec;
    waitPrepareExecute.tv_nsec = time.tv_nsec;
}

void Task::setWaitExecuteFinish(const timespec& time) {
    waitExecuteFinish.tv_sec  = time.tv_sec;
    waitExecuteFinish.tv_nsec = time.tv_nsec;
}

void Task::setWaitFinishNextTask(const timespec& time) {
    waitFinishNextTask.tv_sec  = time.tv_sec;
    waitFinishNextTask.tv_nsec = time.tv_nsec;
}

void Task::setSuccessfulReaction(const vector<bool>& reaction) {
    successfulReaction = reaction;
}

---