Timer.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library 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
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// Timer.cpp: implementation of the Timer class.
//
//////////////////////////////////////////////////////////////////////

#include "Timer.h"

namespace cmlabs {

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Timer::Timer(JString strData, long ms)
{
        endedAt.setInvalid();
        data = strData;
        shouldContinue = true;
        msRuntime = ms;
        object = NULL;
        stringCallback = NULL;
        objectCallback = NULL;
        timerReceiver = NULL;
        timerObjectReceiver = NULL;
//      start();
}

Timer::Timer(Object* obj, long ms) {
        endedAt.setInvalid();
        object = obj;
        shouldContinue = true;
        msRuntime = ms;
        stringCallback = NULL;
        objectCallback = NULL;
        timerReceiver = NULL;
        timerObjectReceiver = NULL;
}

Timer::Timer(JString strData, long ms, void (*function)(JString string))
{
        endedAt.setInvalid();
        data = strData;
        shouldContinue = true;
        stringCallback = function;
        msRuntime = ms;
        object = NULL;
        objectCallback = NULL;
        timerReceiver = NULL;
        timerObjectReceiver = NULL;
//      start();
}

Timer::Timer(Object* obj, long ms, void (*function)(Object* object)) {
        endedAt.setInvalid();
        object = obj;
        shouldContinue = true;
        objectCallback = function;
        msRuntime = ms;
        stringCallback = NULL;
        timerReceiver = NULL;
        timerObjectReceiver = NULL;
}

Timer::Timer(JString strData, long ms, TimerReceiver* receiver) {
        endedAt.setInvalid();
        data = strData;
        shouldContinue = true;
        msRuntime = ms;
        object = NULL;
        timerReceiver = receiver;
        timerObjectReceiver = NULL;
        stringCallback = NULL;
        objectCallback = NULL;
//      start();
}

Timer::Timer(Object* obj, long ms, TimerObjectReceiver* receiver) {
        endedAt.setInvalid();
        object = obj;
        shouldContinue = true;
        msRuntime = ms;
        timerReceiver = NULL;
        timerObjectReceiver = receiver;
        stringCallback = NULL;
        objectCallback = NULL;
}



Timer::~Timer() {
//      printf("Deleting 1 Timer %s...\n", (char*) name); fflush(stdout);
        cancel();
//      printf("Deleting 2 Timer %s...\n", (char*) name); fflush(stdout);
}



void Timer::run() {
        
//      try {

        endedAt.setInvalid();
        startedAt = JTime();
//      printf("Timer Run %s: waiting for %d ms...\n", (char*) name, msRuntime);
        timerSem.wait(msRuntime);
//      printf("Timer Run %s: done waiting for %d ms...\n", (char*) name, msRuntime);

        if (shouldContinue) {
                if (object != NULL) {
                        if (objectCallback != NULL) {
                                (*objectCallback)(object);
                                object = NULL;
                        }
                        else if (timerObjectReceiver != NULL) {
                                timerObjectReceiver->receiveTimerObject(object);
                                object = NULL;
                        }
                }
                else {
                        if (stringCallback != NULL)
                                (*stringCallback)(data);
                        else if (timerReceiver != NULL)
                                timerReceiver->receiveTimerString(data);
                }
        }

//      printf("%s Posting to external sem\n", (char*)data);
        extSem.post();
        endedAt = JTime();

//      printf("####### Timer %s ended ####### \n", (char*) name);

//      }
//      catch(...) {
//              printf("Caught exception in Timer::run()\n"); fflush(stdout);
//      }
}

long Timer::msSinceEnded() {
        JTime now;
        if (!hasEnded())
                return -1;
        else
                return (now - endedAt);
}

bool Timer::hasEnded() {
        return endedAt.isValid();
}

void Timer::cancel() {

        shouldContinue = false;
        stringCallback = NULL;
        objectCallback = NULL;
        timerReceiver = NULL;
        timerObjectReceiver = NULL;
        if (object != NULL) {
                if (DEBUGLEVEL(DETAILEDSTATUS))
                        printf("Deleting Unused Timer Object... "); fflush(stdout);
//              try {
                delete(object);
                object = NULL;
                if (DEBUGLEVEL(DETAILEDSTATUS))
                        printf("Done\n"); fflush(stdout);
//              }
//              catch(...) {}
        }

        if (!hasEnded()) {
                timerSem.post();
                extSem.wait(100);
        }

        // Temporary fix for linux shutdown...
//      #ifdef WIN32
                this->terminate();
//      #endif // WIN32
}


long Timer::msLeft() {
//      return (long) this->getTimer();

        JTime now;
        
//      printf("%d  -  %d\n", msRuntime, (now - startedAt));
        long left = msRuntime - (now - startedAt);

        // if something has gone wrong
        if (left < -1000) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("Timer ran out long ago... ERROR!\n");
                }
                shouldContinue = false;
                timerSem.post();
        }

        return left;
}

long Timer::waitFor() {

        JTime start;
        // JTime now;
        //      printf("%s: waitFor...\n", (char*)data);
        long ms = -1;
//      try {
                while ((ms=msLeft()) > 0) {
//                      printf("[%s]", (int)ms);
                        extSem.wait(ms/2);
//                      printf("(%s)", (int)ms);
//                      wait(50);
                }
                // now = JTime();
                ms = start.getAge();
//      } catch(...) {}
//      printf("%s: done waitFor, took: %d\n", (char*)data, ms);

        return ms;
}


void Timer::OnTimer() {
        // When timer expires signal sem
        timerSem.post();
}

Object* Timer::getAndRemoveObject() {
        Object* obj = object;
        object = NULL;
        return obj;
}


} // namespace cmlabs

---