timers.php

<?php
/*
+---------------------------------------------------------------------------
|   PHP-IRC v2.2.1 Service Release
|   ========================================================
|   by Manick
|   (c) 2001-2005 by http://www.phpbots.org/
|   Contact: manick@manekian.com
|   irc: #manekian@irc.rizon.net
|   ========================================
+---------------------------------------------------------------------------
|   > timers module
|   > Module written by Manick
|   > Module Version Number: 2.2.0
+---------------------------------------------------------------------------
|   > 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 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.
+---------------------------------------------------------------------------
|   Changes
|   =======-------
|   > If you wish to suggest or submit an update/change to the source
|   > code, email me at manick@manekian.com with the change, and I
|   > will look to adding it in as soon as I can.
+---------------------------------------------------------------------------
*/

/*
 * Redesigned 12/22/04... Yes... this file sucks.  I basically am going to
 * do a few things here.  I have been stuck on this file for the past 2 weeks,
 * trying to come up with some ideas to handle the hopeless situation which
 * faced me.  With the new queue system, this timer class became very interesting
 * to handle.  I had to decide how I would add proc queues to the queue class
 * to handle specific timers in this file.  Say, for instance, that a timer
 * is added, and then another is added that has a shorter time than that one.
 * The first one will have a proc queue added into the queue class, but then
 * the second one will have to add another proc queue.  But hold on a second,
 * the way this works right now, after a timer is done running, the next one
 * is added to the process queue.  I handled this by keeping track of how
 * many processes were in the queue, and didn't add one if there were more than
 * one, and the call to setCurrentTimer was from handle().  This worked, unless
 * you have a timer that repeats.  Then the problem comes in, as it will not be
 * added to the proc queue until the next timer is complete.  To just handle 
 * this problem, I'm just going to add a proc to the queue for every timer
 * that is added, and then every timer will have a queue in the procqueue.
 * that way, we don't have to worry about anything.
 *
 * Also, I added a "timerStack" so that I could have reserved names and what
 * not.  Each timer gets a unique name or ID, and that is added to the stack,
 * as well as sorted into the timerList.
 *
 * Okay, way that timers are handled... has changed, if you want a timer to 
 * repeat, you must return true from the timer, runOnce was removed.
 *
 * Ooohh oohh ohh! Idea.  screw linked lists and shit.  I'll just add each
 * timer to the proc queue, and then have them call handle() with the timer
 * referenced! This solves all problems, and is incredibly more efficient!
 * This officially takes the last linked list out of my bot.  I have NO IDEA
 * why I even used them in the first place, as php already has associative arrays
 * which are a lot better! GEEZ!
 */

class timers
{

    //Local variables
    private $timerStack = array();    //list of all timers indexed by name

    //External Classes
    private $procQueue;
    private $socketClass;
    private $ircClass;

    //Private list of reserved php-irc timer names (please do not
    //use these names)
    private $reserved = array("listening_timer_[0-9]*",
        "check_nick_timer",
        "check_channels_timer",
        "check_ping_timeout_timer",
    );

    public function __construct()
    {
        $this->time = time();
        $this->timerStack = array();
    }

    public function setSocketClass($class)
    {
        $this->socketClass = $class;
    }

    public function setIrcClass($class)
    {
        $this->ircClass = $class;
    }

    public function setProcQueue($class)
    {
        $this->procQueue = $class;
    }

    public static function getMicroTime()
    {
        return microtime(true);
    }

    public function getTimers()
    {
        return $this->timerStack;
    }

    public function handle($timer)
    {
        $microTime = self::getMicroTime();

        if (!isset($this->timerStack[$timer->name])) {
            return false;
        }

        if ($this->timerStack[$timer->name] !== $timer) {
            return false;
        }

        $timer->lastTimeRun = $microTime;
        $timer->nextRunTime = $microTime + $timer->interval;

        if ($timer->class != null) {
            $theFunc = $timer->func;
            $status = $timer->class->$theFunc($timer->args);
        } else {
            $theFunc = $timer->func;
            $status = $theFunc($timer->args);
        }

        if ($status != true) {
            $this->removeTimer($timer->name);
        } else {
            $this->procQueue->addQueue($this->ircClass, $this, "handle", $timer, $timer->interval);
        }

        return false;
    }

    public function removeAllTimers()
    {
        foreach ($this->timerStack AS $timer) {
            $this->removeTimer($timer->name);
        }
    }


    public function addTimer($name, $class, $function, $args, $interval, $runRightAway = false)
    {
        if (trim($name) == "") {
            return false;
        }

        if (isset($this->timerStack[$name])) {
            return false;
        }

        $newTimer = new timer;

        $newTimer->name = $name;
        $newTimer->class = $class;
        $newTimer->func = $function;
        $newTimer->args = $args;
        $newTimer->interval = $interval;
        $newTimer->removed = false;

        if ($runRightAway == false) {
            $newTimer->lastTimeRun = $this->getMicroTime();
            $newTimer->nextRunTime = $this->getMicroTime() + $interval;
            $tInterval = $interval;
        } else {
            $newTimer->lastTimeRun = 0;
            $newTimer->nextRunTime = $this->getMicroTime();
            $tInterval = 0;
        }

        $this->procQueue->addQueue($this->ircClass, $this, "handle", $newTimer, $tInterval);

        $this->timerStack[$newTimer->name] = $newTimer;

        return $name;
    }

    /* Remove the current timer from both the list and stack, changed in 2.1.2, can only call by
     * timer name now.
     */
    public function removeTimer($name)
    {
        if (!isset($this->timerStack[$name])) {
            return false;
        }

        //Set removed flag,
        $this->timerStack[$name]->removed = true;

        //Remove from stack
        unset($this->timerStack[$name]->args);
        unset($this->timerStack[$name]->class);
        unset($this->timerStack[$name]);

        return true;
    }

}

?>