TimerManager.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

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

#include "TimerManager.h"

namespace cmlabs {

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

TimerManager::TimerManager()
{
        timerList = new ObjectDictionary();
        timerList->doDelete();
}

TimerManager::~TimerManager()
{
        cancelAll();
        // Temporary fix for linux shutdown...
//      #ifdef WIN32
                delete(timerList);
//      #endif // WIN32
}

JString TimerManager::createTimer(JString strData, long ms) {
        doMaintenance();
        JString id = createUniqueID("timer");
        Timer* t = new Timer(strData, ms);
//      id += JString::format("[%d]", (int)t->hThread);
        timerList->put(id, t);
        t->name = id;
        t->start();
        return id;
}

JString TimerManager::createTimer(Object* obj, long ms) {
        doMaintenance();
        JString id = createUniqueID("timer");
        Timer* t = new Timer(obj, ms);
//      id += JString::format("[%d]", (int)t->hThread);
        timerList->put(id, t);
        t->name = id;
        t->start();
        return id;
}

JString TimerManager::createTimer(JString strData, long ms, void (*function)(JString id)) {
        doMaintenance();
        JString id = createUniqueID("timer");
        Timer* t = new Timer(strData, ms, function);
//      id += JString::format("[%d]", (int)t->hThread);
        timerList->put(id, t);
        t->name = id;
        t->start();
        return id;
}

JString TimerManager::createTimer(Object* obj, long ms, void (*function)(Object* object)) {
        doMaintenance();
        JString id = createUniqueID("timer");
        Timer* t = new Timer(obj, ms, function);
//      id += JString::format("[%d]", (int)t->hThread);
        timerList->put(id, t);
        t->name = id;
        t->start();
        return id;
}

JString TimerManager::createTimer(JString strData, long ms, TimerReceiver* receiver) {
        doMaintenance();
        JString id = createUniqueID("timer");
        Timer* t = new Timer(strData, ms, receiver);
//      id += JString::format("[%d]", (int)t->hThread);
        timerList->put(id, t);
        t->name = id;
        t->start();
        return id;
}

JString TimerManager::createTimer(Object* obj, long ms, TimerObjectReceiver* receiver) {
        doMaintenance();
        JString id = createUniqueID("timer");
        Timer* t = new Timer(obj, ms, receiver);
//      id += JString::format("[%d]", (int)t->hThread);
        timerList->put(id, t);
        t->name = id;
        t->start();
        return id;
}

void TimerManager::doMaintenance() {

//      printf("Maintenance Start..........................\n"); fflush(stdout);
        Collection removes;

        JString key;
        Timer* timer;
        for (int n=0; n<timerList->getCount(); n++) {
                key = timerList->getKey(n);
                timer = (Timer*) timerList->get(key);
                if (timer != NULL) {
                        if (timer->msSinceEnded() > 100) {
                        //      printf("Timer %s is done %d / %d!\n", (char*) key, timer->msLeft(), timer->msSinceEnded());
                                removes.add(key);
                        }
                        else {
                        //      printf("Timer %s is active: %d / %d!\n", (char*) key, timer->msLeft(), timer->msSinceEnded());
                        }
                }
        }

        for (int m=0; m<removes.getCount(); m++) {
                // timerList->remove(removes.get(m));
                key = removes.get(m);
                if (!cancel(key)) {
                        if (DEBUGLEVEL(DEBUG))
                                printf("Failed Removed Timer %s!\n", (char*) key);
                }
                //else
                //      printf("Removed Timer %s!\n", (char*) key);
        }
        // printf("Maintenance End..........................\n"); fflush(stdout);

}

bool TimerManager::cancel(JString id) {
//      try {
                Timer* t = (Timer*) timerList->get(id);
                if (t != NULL) {
                /*      t->cancel();
                        int cc = 0;
                        while (t->isRunning()) {
                                t->wait(10);
                                if ((cc++) > 5) break;
                        }*/
                        // t->cancel();
                        timerList->remove(id);
                        return true;
                }
//      } catch(...) {}
        return false;
}

bool TimerManager::cancelAll() {

        JString key;
        Timer* timer;
//      while (timerList->getCount() > 0) {
        for (int n=0; n<timerList->getCount(); n++) {
                key = timerList->getKey(n);
                timer = (Timer*) timerList->get(key);
                if (timer != NULL) {
                        if (timer->isRunning())
                                if (DEBUGLEVEL(DEBUG))
                                        printf("  Timer %s is active: %d / %d!\n", (char*) key, timer->msLeft(), timer->msSinceEnded());
                //      else
                //              printf("Timer %s is done %d / %d !\n", (char*) key, timer->msLeft(), timer->msSinceEnded());
                        timer->cancel();
                        wait(0);
                }
        }

        // Temporary fix for linux shutdown...
//      #ifdef WIN32
                doMaintenance();
//      #endif // WIN32
        return true;
}

long TimerManager::waitFor(JString id) {
        Timer* t = getTimer(id);
        long res = -22222;
        if (t != NULL) {
                res = t->waitFor();
                if (t->msLeft() == 0)
                        timerList->remove(id);
        }
        return res;
}

long TimerManager::msLeft(JString id) {
        Timer* t = getTimer(id);
        if (t != NULL)
                return t->msLeft();
        return -11111;
}

Timer* TimerManager::getTimer(JString id) {
        Timer* t = NULL;
//      try {
                t = (Timer*) timerList->get(id);
//      } catch(...) {}
//      if (t != NULL)
//              printf("Wanting %s, got %s\n", (char*) id, (char*) t->data);
        return t;
}


int TimerManager::getActiveTimerCount() {
        return timerList->getCount();
}

Collection TimerManager::getActiveTimerIDs() {
        return timerList->getAllKeys();
}



bool TimerManager::unitTest() {

        int base = 500;

        #if defined(_WIN32_WCE)
                base = 1000;
        #endif

        int max = 6;
        JSemaphore** sems = new JSemaphore*[max];
        int n;

        this->addUnitTestLog("Starting test...");

        for (n=0; n<max; n++) {
                printf("%d\b", n); fflush(stdout);
                sems[n] = new JSemaphore(JString(n));
                this->createTimer(sems[n], (n+1)*base, this);
        }

        for (n=0; n<max; n++) {
                printf("O%d\b\b", n); fflush(stdout);
                if (sems[n]->tryWait()) {
                //      printf("Semaphore %d should not have been triggered yet...\n", n);
                        this->addUnitTestLog(JString::format("FAILED: Semaphore %d triggered early 1...", n));
                //      return false;
                }
        }


        for (n=0; n<max; n++) {
                printf("OO%d\b\b\b", n); fflush(stdout);
                wait(base+10);
        //      printf("Testing Semaphore %d... ", n);          
                if (!sems[n]->tryWait()) {
                        printf("FAILED: Semaphore %d should have been triggered by now...\n", n);               
                        this->addUnitTestLog(JString::format("FAILED: Semaphore %d should have been triggered by now...", n));
                        return false;
                }
                else {
        //              printf("SUCCESS\n");
                }
                if (n == (max/2)) {
        //              printf("Maintenance Cycle...\n");
                        this->createTimer(sems[0], (max-n+1)*base, this);
                        this->createTimer(sems[1], (max-n+2)*base, this);
                        this->createTimer(sems[2], (max-n+3)*base, this);
        //              printf("Maintenance Cycle Done...\n");
                }
        }

        printf("OOO.\b\b\b\b"); fflush(stdout);
        if (sems[0]->tryWait()) {
                this->addUnitTestLog("Semaphore 0 triggered early 2");
                return false;
        }

        printf("OOO0\b\b\b\b"); fflush(stdout);
        if (!sems[0]->wait(5000)) {
                printf("FAILED: Last Semaphore should have been triggered by now...\n");
                this->addUnitTestLog("Semaphore 0 should have been done");
                return false;
        }

        printf("OOO1\b\b\b\b"); fflush(stdout);
        if (!sems[1]->wait(5000)) {
                this->addUnitTestLog("Semaphore 1 should have been done");
                return false;
        }

        printf("OOO2\b\b\b\b"); fflush(stdout);
        if (!sems[2]->wait(5000)) {
                this->addUnitTestLog("Semaphore 2 should have been done");
                return false;
        }

        wait(base);

//      printf("OOOM\b\b\b\b"); fflush(stdout);
        this->doMaintenance();

        printf("OOOC\b\b\b\b"); fflush(stdout);
        for (n=0; n<max; n++)
                delete(sems[n]);

        delete [] sems;
        printf("OOOO\b\b\b\b"); fflush(stdout);
        return true;




/*
        try {
                long wait1 = 500;
                long wait2 = 200;
                long ms, t;

                JString id1 = createTimer("1", wait1);
                JString id2 = createTimer("2", wait2);
                
                // check time left of id2
                t = ms = msLeft(id2);
                        sprintf(str, "timeleft: %d < wait2*0.4: %d", ms, (int)(wait2*0.4));
//                      printf("%s\n", str);
                if (ms < (wait2*0.4)) {
                        this->addUnitTestLog(str);
                        return false;
                }

                // wait for and check the waited
                ms = waitFor(id2);
                        sprintf(str, "waited: %d < t*0.8: %d", ms, (int)(t*0.8));
//                      printf("%s\n", str);
                if (ms < (t*0.8)) {
                        this->addUnitTestLog(str);
                        return false;
                }

                // check time left of id1
                t = ms = msLeft(id1);
                        sprintf(str, "timeleft: %d < ((wait1-wait2)*0.4): %d", ms, (int)((wait1-wait2)*0.4));
//                      printf("%s\n", str);
                if (ms < ((wait1-wait2)*0.4)) {
                        this->addUnitTestLog(str);
                        return false;
                }


                ms = waitFor(id1);
//              if ( (ms < ((wait1-wait2)*0.4)) || (ms > ((wait1-wait2)*1.5)) )
                        sprintf(str, "2 waited: %d < t*0.8: %d", ms, (int)(t*0.8));
//                      printf("%s\n", str);
                if (ms < (t*0.6)) {
                        this->addUnitTestLog(str);
                        return false;
                }



                ms = msLeft(id1);
                if (ms >= 0) {
                        sprintf(str, "id1 should be gone now... %d ", ms);
                        printf("%s\n", str);
                        this->addUnitTestLog(str);
                        return false;
                }

                ms = msLeft(id2);
                if (ms >= 0) {
                        sprintf(str, "id2 should be gone now... %d ", ms);
                        printf("%s\n", str);
                        this->addUnitTestLog(str);
                        return false;
                }

                return true;
        } catch(...) {
                sprintf(str, "Caught try!");
                printf("%s\n", str);
                this->addUnitTestLog(str);
        }

        return false;
*/
}


//! For testing only
bool TimerManager::receiveTimerObject(Object* obj) {
        
        JSemaphore* sem = (JSemaphore*) obj;
        if (obj == NULL) {
                printf("Received NULL object instead of semaphore...\n");
        }
        else {
        //      printf("Received semaphore %s... Triggering... ", (char*) sem->name);
                sem->post();
        //      printf("Triggered\n");
        }
        return true;
}


} // namespace cmlabs

---