ptfcore.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/ptfcore.hpp>
#include <ptf/environment/clock.hpp>
#include <ptf/environment/graphic.hpp>
#include <ptf/environment/audio.hpp>
#include <ptf/environment/parallel.hpp>
#include <stdlib.h>
#include <stdexcept>

PtfCore::PtfCore(int argc, char** argv) {
    try {
        // set to null pointer
        scheduler = 0;
        handler = 0;
        iterator = 0;
        // fullscreen flag
        bool fullscreen = false;
        // parse arguments
        for(int i = 0; i < argc; i++){
            if (argv[i][0]=='-'){
                if(argv[i][1]=='f'){
                    fullscreen = true;
                    messageLog << MESSAGE("Using Fullscreen\n");
                } 
                else {
                    messageLog << ERROR("Unkown command line option: ") << argv[i] ;             
                    throw std::runtime_error("Unknown command line option");
                }
            }   
        }
        // create libraries
        new Clock();
        new Audio();
        new Graphic();
        new Parallel();
        // open a window
        Graphic::getSingleton().createWindow(500, 500, fullscreen);
    }
    catch(std::runtime_error& x) {
        messageLog << ERROR("Unhandled error caught: ") << x.what() << " ";
        messageLog << "Exiting now.\n"; 
        exit(1);   
    }
    catch(...) {
        messageLog << ERROR("Unknown error encountered. Exiting now.\n");
        exit(1);       
    }
}

PtfCore::~PtfCore() {
    // clean up graphic library
    delete Graphic::getSingletonPtr();
    // clean up audio library
    delete Audio::getSingletonPtr();
    // clean up clock
    delete Clock::getSingletonPtr();
    // clean up parallel port
    delete Parallel::getSingletonPtr();
    // clean up SDL lib
    SDL_Quit();
}

void PtfCore::run() {
    try {
        // prevent output to screen
        machineLog.setSilent(true);
        // check for needed things
        if (scheduler == 0){
            messageLog << WARNING("No Scheduler specified, using default.\n");
            scheduler = new Scheduler();
        }
        if (handler == 0){
            messageLog << WARNING("No ReactionHandler specified. Reactions will not be handled.\n");
            handler = new ReactionHandler();
        }
        if (iterator == 0){
            messageLog << WARNING("No SequenceIterator specified, using default.\n");
            iterator = new DefaultSequenceIterator();
        }
        if (inputDevices.size() == 0){
            messageLog << WARNING("No InputDevice specified. No reactions will be generated.\n");
        }
        // start all input devices
        for (int i = 0; i < (int)inputDevices.size(); i++) {
            inputDevices[i]->startPolling();
        }
        // start scheduling
        scheduler->schedule();
        // stop all input devices
        for (int i = 0; i < (int)inputDevices.size(); i++) {
            inputDevices[i]->stopPolling();
        }
        // save log files
        taskLog.saveToFile("task.log");
        messageLog.saveToFile("message.log");
        handlerLog.saveToFile("handler.log");
        eventLog.saveToFile("event.log");
        machineLog.saveToFile("machine.log");
    }
    catch(std::runtime_error& x) {
        messageLog << ERROR("Unhandled error caught: " << x.what() << " ");
        messageLog << "Exiting now.\n";
        exit(1);
    }
    catch(...) {
        messageLog << ERROR("Unknown error encountered. Exiting now.\n");
        exit(1);       
    }
}

void PtfCore::setScheduler(Scheduler* taskScheduler){
    scheduler = taskScheduler;  
}

void PtfCore::setReactionHandler(ReactionHandler* reactionHandler){
    handler = reactionHandler;
}

void PtfCore::setSequenceIterator(SequenceIterator* sequenceIterator){
    iterator = sequenceIterator;
}

Scheduler& PtfCore::getScheduler() {
    return *scheduler;
}

ReactionHandler& PtfCore::getReactionHandler() {
    return *handler;    
}

SequenceIterator& PtfCore::getSequenceIterator() {
    return *iterator;
}

vector<Sequence*>& PtfCore::getSequences() {
    return sequences;
}

vector<ReactionRecord*>& PtfCore::getReactionRecords() {
    return reactionRecords;
}

vector<TaskRecord*>& PtfCore::getTaskRecords() {
    return taskRecords;
}

vector<InputDevice*>& PtfCore::getInputDevices() {
    return inputDevices;
}

Mutex& PtfCore::getReactionRecordsMutex() {
    return reactionRecordsMutex;
}

Mutex& PtfCore::getTaskRecordsMutex() {
    return taskRecordsMutex;
}

const vector<Task*>& PtfCore::getTasks() const {
    return tasks;
}

void PtfCore::taskRegistrationHelper(Task* task) {
    // get id of task to add
    int id = task->getId();
    // fill tasks vector with null pointers so that we can add the task safely (only if necessary)
    if ((int)tasks.size() <= id) {
        int n = id - (int)tasks.size() + 1;
        for (int i = 0; i < n; i++) {
            tasks.push_back(0);
        }
        
    }
    // set entry to task
    tasks[id] = task;
}

Log& PtfCore::getMessageLog() {
    return messageLog;
}

Log& PtfCore::getHandlerLog() {
    return handlerLog;
}

Log& PtfCore::getTaskLog() {
    return taskLog;
}

Log& PtfCore::getEventLog() {
    return eventLog;
}

Log& PtfCore::getMachineLog() {
    return machineLog;
}

---