<?php

//--------------------------------------------
// A dispatcher. This class deals with managing
// observer classes and notifying these observers
// about events.
//--------------------------------------------

class FADispatcher 
{
    //--------------------------------------------
    // An array of the observers that this dispatcher
    // will notify about incoming events.
    //--------------------------------------------
    
    var $_observers = array();
    
    //--------------------------------------------
    // Add an observer to the above array so that when
    // the dispatcher is told to notifyAll (notify all
    // observers) then we will have an/some observers to
    // notify!
    //--------------------------------------------
    
    function addObserver(&$observer) 
    {
        //--------------------------------------------
        // Make sure that it's actually an observer being
        // passed in.
        //--------------------------------------------
        
        assert(is_a($observer, 'FAObserver'));
        
        //--------------------------------------------
        // Add an observer to the array of observers.
        //--------------------------------------------
        
        $this->_observers[] = &$observer;
    }
    
    //--------------------------------------------
    // Notify all of the observers in the _observers
    // array about $event.
    //--------------------------------------------
    
    function notifyAll(&$event) 
    {
        //--------------------------------------------
        // Make sure the even being passed is observable.
        //--------------------------------------------
        
        assert(is_a($event, 'FAObservableEvent'));
        
        $ret = FALSE;

        for($i = 0; $i < count($this->_observers); $i++)
        {
            //--------------------------------------------
            // Get one of the observers.
            //--------------------------------------------
            
            $observer = &$this->_observers[$i];
            
            //--------------------------------------------
            // If an observer has successfully been notified,
            // stop notifying observers.
            //--------------------------------------------
            
            if($ret = (bool)$observer->notify($event)) 
            {
                break;
            }
        }
        
        return $ret;
    }
}

//--------------------------------------------
// The base observer class. This class cannot
// be used directly.
//--------------------------------------------

class FAObserver 
{
    //--------------------------------------------
    // Notify this observer about an incoming event.
    //--------------------------------------------
    
    function notify(&$event) 
    {
        assert(FALSE);
    }
}

//--------------------------------------------
// The observable event class... Not much to say
// here.
//--------------------------------------------

class FAObservableEvent 
{
}

//--------------------------------------------
// An observable database query event. This class holds
// information about a specific database query.
//--------------------------------------------

class DatabaseQueryEvent extends FAObservableEvent 
{
    var $_sql;
    var $_rows;
    var $_time;
    
    //--------------------------------------------
    // Constructor. The variables passed in are:
    // $sql - the SQL query
    // $rows - the number of rows that the sql query affected
    // $time - the number of microseconds that the query took
    //         to execute.
    //--------------------------------------------
    
    function DatabaseQueryEvent($sql, $rows = 0, $time = 0) 
    {
        $this->_sql = $sql;
        $this->_rows = $rows;
        $this->_time = $time;
    }
    
    //--------------------------------------------
    // Get the SQL of the query used.
    //--------------------------------------------
    
    function getQuery() 
    {
        return $this->_sql;
    }
    
    //--------------------------------------------
    // Get the number of rows that the query affected.
    //--------------------------------------------
    
    function getRows() 
    {
        return $this->_rows;
    }
    
    //--------------------------------------------
    // Get the number of microseconds that the query
    // took to execute.
    //--------------------------------------------
    
    function getTime()
    {
        return $this->_time;
    }
}

//--------------------------------------------
// The database observer class. This class collects
// database query events.
//--------------------------------------------

class DatabaseObserver extends FAObserver 
{
    //--------------------------------------------
    // An array of database query events.
    //--------------------------------------------
    
    var $_events = array();
    
    //--------------------------------------------
    // Notify this observer about an event. In this case
    // it will be a database query event. Push that event
    // onto the array of events.
    //--------------------------------------------
    
    function notify(&$event) 
    {
        $this->_events[] = $event;
    }
    
    //--------------------------------------------
    // Return the array of all of the database query
    // events.
    //--------------------------------------------
    
    function getEvents() 
    {
        return $this->_events;
    }
}

//--------------------------------------------
// Our base class for the database abstraction layer.
// This class deals with setting up and managing the
// dispatcher that we are using.
//--------------------------------------------

class FADatabaseConnection
{
    //--------------------------------------------
    // The dispatcher that the database abstraction layer
    // will use to notify observers about events.
    //--------------------------------------------
    
    var $_dispatcher;
    
    //--------------------------------------------
    // Constructor, instanciate a new dispatcher to deal
    // with notifying any observers added to it about events.
    //--------------------------------------------
    
    function FADatabaseConnection()
    {
        $this->_dispatcher = &new FADispatcher();
    }
    
    //--------------------------------------------
    // Add observers to this dispatcher so that when this
    // dispatcher is notified about events, it can tell
    // the observers about them.
    //--------------------------------------------
    
    function addObserver(&$observer)
    {
        $this->_dispatcher->addObserver($observer);
    }
    
    //--------------------------------------------
    // Notify any observer in the dispatcher about
    // an event.
    //--------------------------------------------
    
    function notifyAll(&$event)
    {
        $this->_dispatcher->notifyAll($event);
    }
    
    //--------------------------------------------
    // The execute query method, this method will execute
    // a query on a database.
    //--------------------------------------------
    
    function executeQuery($sql = '')
    {
        assert(FALSE);
    }
}

//--------------------------------------------
// This would normally be an abstraction layer for
// something like MySQL or PostgreSQL... For this example,
// we are dealing with the ever ambiguous SomeSQL!
//--------------------------------------------

class SomeSQL extends FADatabaseConnection
{
    //--------------------------------------------
    // Execute a database query
    //--------------------------------------------
    
    function executeQuery($sql)
    {
        //--------------------------------------------
        // Now, these two variables would normally take
        // their values from something like mysql_affected_rows
        // and by putting two microtime()'s around the execution
        // of the query and finding the difference. But, we won't
        // do that in this example.. mwahahaha.
        //--------------------------------------------
        
        $execution_time = microtime();
        $affected_rows = 0;
        
        //--------------------------------------------
        // Normally one would call the query method for a database here.
        //--------------------------------------------
        
        //--------------------------------------------
        // Aha! Instanciate a new database query event
        // (an observable event) and pass it to the notifyAll
        // function. The notifyAll function calls FADispatcher::notifyAll
        // which in turn calls FAObserver::notify! What a nice
        // chain of events.
        //--------------------------------------------
        
        $this->notifyAll(new DatabaseQueryEvent($sql, $affected_rows, $execution_time));
    }
}

//--------------------------------------------
// Instanciate our observer. By the end of execution,
// this observer will hold and array of information
// for all of the database queries.
//--------------------------------------------

$observer = &new DatabaseObserver;

//--------------------------------------------
// Instanciate our SomeSQL database abstraction layer
// and add the above observer to the dispatcher that
// was implicitly instanciated when SomeSQL was.
//--------------------------------------------

$dba = &new SomeSQL;
$dba->addObserver($observer);

//--------------------------------------------
// Execute a dummy query just for the sake of this
// example.
//--------------------------------------------

$dba->executeQuery("SELECT moo FROM cow WHERE alive=1");

//--------------------------------------------
// Debug time! Let's loop over all of the query
// events stored in the observer and make a table
// with some debug information.
//--------------------------------------------

$html = "";
$html .= "<table border=\"1\">";
$html .= "<tr><th>Query</th><th>Query Time</th><th>Affected Rows</th></tr>";

$i = 0;
foreach($observer->getEvents() as $event) {
    $html .= "\n\t<tr>";
    $html .= "\n\t\t<td>\n\t\t\t" . $event->getQuery() . "\n\t\t</td>";
    $html .= "\n\t\t<td>\n\t\t\t" . $event->getTime() . "\n\t\t</td>";
    $html .= "\n\t\t<td>\n\t\t\t" . $event->getRows() . "\n\t\t</td>";
    $html .= "\n\t</tr>";

    $i++;
}
$html .= "\n</table>";

echo $html;
?>