Source for file Server.class.php

Documentation is available at Server.class.php

  1. <?php
  2. /**
  3.  * Gumbo Library Framework
  4.  *
  5.  * LICENSE
  6.  * This library is being released under the terms of the New BSD License.  A
  7.  * copy of the license is packaged with the software (LICENSE.txt).  If no
  8.  * copy is found, a copy of the license template can be found at:
  9.  * http://www.opensource.org/licenses/bsd-license.php
  10.  * 
  11.  * @category Gumbo
  12.  * @package Debug
  13.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  14.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  15.  * @author Michael Luster <mluster79@yahoo.com>
  16.  * @link http://sourceforge.net/projects/phpgumbo
  17.  * @version 0.0.1
  18.  */
  19.  
  20. /**
  21.  * Debug Server Class
  22.  *
  23.  * @category Gumbo
  24.  * @package Debug
  25.  * @copyright Copyright (c) 2007, iBayou, Michael Luster
  26.  * @license http://www.opensource.org/licenses/bsd-license.php New BSD License
  27.  * @author Michael Luster <mluster79@yahoo.com>
  28.  * @link http://sourceforge.net/projects/phpgumbo
  29.  * @desc Debug Server Class
  30.  * @version 0.0.1
  31.  */
  32.  
  33. gumbo_load ("Interface_Singleton");
  34. gumbo_load ("Interface_Output");
  35. gumbo_load ("Factory");
  36. gumbo_load ("Debug_Server_Blank");
  37.  
  38. class Gumbo_Debug_Server extends Gumbo_Factory implements Gumbo_Interface_Singleton, Gumbo_Interface_Output {
  39.     
  40.     /** @var Gumbo_Interface_Debug_Server $_instance */
  41.     private static $_instance = null;
  42.     
  43.     /** @var Gumbo_Interface_Debug_Server_Report $_reports */
  44.     private $_reports = false;
  45.     
  46.     
  47.     
  48.     /**
  49.      * Constructor
  50.      */
  51.     private function __construct () {}
  52.     
  53.     /**
  54.      * Singleton Method
  55.      * @return Gumbo_Interface_Debug_Server 
  56.      */
  57.     public static function instance () {
  58.         if (self::$_instance == null) {
  59.             self::$_instance = new Gumbo_Debug_Server ();
  60.         }
  61.         return self::$_instance;
  62.     }
  63.     
  64.     
  65.     
  66.     /** ACTION METHODS **/
  67.     /**
  68.      * Returns a Debug Server Report
  69.      * @param string $name name of Class or key string
  70.      * @param mixed $args additional arguments
  71.      * @return Gumbo_Interface_Debug_Server_Report 
  72.      * @throws Gumbo_Exception
  73.      * @uses Gumbo_Debug_Server_Blank
  74.      */
  75.     public function factory ($name=null, $args=null) {
  76.         try {
  77.             // prepend Gumbo_Filter_ if class does not exist
  78.             if (is_string ($name) && !class_exists ($name, false)) {
  79.                 $name = "Gumbo_Debug_Server_" . ucfirst (str_replace ("Gumbo_Debug_Server_", "", $name));
  80.             }
  81.             
  82.             $args = array ();
  83.             $args [] = $name;
  84.             foreach (func_get_args () as $key=>$val) {
  85.                 if ($key == 0) { continue; }
  86.                 $args [] = $val;
  87.             }
  88.             
  89.             $obj = call_user_func_array (array ("parent", "factory"), $args);
  90.             
  91.             if (!($obj instanceof Gumbo_Interface_Debug_Server_Report)) {
  92.                 throw new Gumbo_Exception ("Invalid Debug Server Report: " . get_class ($obj));
  93.             }
  94.             
  95.             return $obj;
  96.         } catch (Gumbo_Exception $e) {
  97.             $e->setFunction (__METHOD__);
  98.             gumbo_trigger ($e);
  99.         }
  100.         return new Gumbo_Debug_Server_Blank ();
  101.     }
  102.     
  103.     /**
  104.      * Activates a Server Report
  105.      * @param string $report Debug Server Report Name
  106.      * @param arr $args additional arguments
  107.      * @throws Gumbo_Exception
  108.      * @uses Gumbo_Debug_Server_Blank
  109.      */
  110.     public function activate ($report, $args=null) {
  111.         try {
  112.             // verify precondition
  113.             if (!is_string ($report)) {
  114.                 throw new Gumbo_Exception ("Invalid Argument 'report:str' => {$report}:" . gettype ($report));
  115.             }
  116.             if (!$this->exists ($report)) {
  117.                 throw new Gumbo_Exception ("Debug Server Report Not Found: {$report}");
  118.             }
  119.             if ($this->isActive ($report)) {
  120.                 throw new Gumbo_Exception ("Debug Server Report Active: {$report}");
  121.             }
  122.             
  123.             $args = func_get_args ();
  124.             $obj = call_user_func_array (array ($this, "factory"), $args);
  125.             if (!($obj instanceof Gumbo_Debug_Server_Blank)) {
  126.                 $this->_reports [$report] = $obj;
  127.             }
  128.         } catch (Gumbo_Exception $e) {
  129.             $e->setFunction (__METHOD__);
  130.             gumbo_trigger ($e);
  131.         }
  132.     }
  133.     
  134.     /**
  135.      * Deactivates a Server Report
  136.      * @param string $report Debug Server Report Name
  137.      * @throws Gumbo_Exception
  138.      */
  139.     public function deactivate ($report) {
  140.         try {
  141.             // verify precondition
  142.             if (!is_string ($report)) {
  143.                 throw new Gumbo_Exception ("Invalid Argument 'report:str' => {$report}:" . gettype ($report));
  144.             }
  145.             if (!$this->isActive ($report)) {
  146.                 throw new Gumbo_Exception ("Debug Server Report Not Active: {$report}");
  147.             }
  148.             
  149.             unset ($this->_reports [$report]);
  150.         } catch (Gumbo_Exception $e) {
  151.             $e->setFunction (__METHOD__);
  152.             gumbo_trigger ($e);
  153.         }
  154.     }
  155.     
  156.     /**
  157.      * Resets the Reports
  158.      * @postcondition !isActive()
  159.      */
  160.     public function reset () {
  161.         $this->_reports = array ();
  162.     }
  163.     
  164.     /**
  165.      * Displays to the browser
  166.      */
  167.     public function display () {
  168.         echo $this->fetch ();
  169.     }
  170.     
  171.     /**
  172.      * Returns the formatted text to the browser
  173.      * @param bool $reload reloads the output
  174.      * @return string 
  175.      */
  176.     public function fetch ($reload=false) {
  177.         $txt = false;
  178.         
  179.         foreach ($this->getReports () as $key=>$report) {
  180.             $txt .= $report->run ();
  181.         }
  182.         
  183.         return $txt;
  184.     }
  185.     
  186.     
  187.     
  188.     
  189.     /** ACCESSOR METHODS **/
  190.     /**
  191.      * Returns a single Report
  192.      * @param string $report 
  193.      * @return Gumbo_Interface_Debug_Server_Report 
  194.      * @throws Gumbo_Exception
  195.      */
  196.     public function getReport ($report) {
  197.         try {
  198.             // verify precondition
  199.             if (!is_string ($report)) {
  200.                 throw new Gumbo_Exception ("Invalid Argument 'report:str' => {$report}:" . gettype ($report));
  201.             }
  202.             if (!$this->isActive ($report)) {
  203.                 throw new Gumbo_Exception ("Debug Server Report Not Active: {$report}");
  204.             }
  205.             
  206.             return $this->_reports [$report];
  207.         } catch (Gumbo_Exception $e) {
  208.             $e->setFunction (__METHOD__);
  209.             gumbo_trigger ($e);
  210.         }
  211.         return null;
  212.     }
  213.     
  214.     /**
  215.      * Returns the Debug Server Reports
  216.      * @return Gumbo_Interface_Debug_Server_Report[] 
  217.      */
  218.     public function getReports () {
  219.         return $this->_reports;
  220.     }
  221.     
  222.     /**
  223.      * Returns if a particular Report is active
  224.      * @param string $report 
  225.      * @return bool 
  226.      * @throws Gumbo_Exception
  227.      */
  228.     public function isActive ($report) {
  229.         try {
  230.             // verify precondition
  231.             if (!is_string ($report)) {
  232.                 throw new Gumbo_Exception ("Invalid Argument 'report:str' => {$report}:" . gettype ($report));
  233.             }
  234.             
  235.             return isset ($this->_reports [$report]);
  236.         } catch (Gumbo_Exception $e) {
  237.             $e->setFunction (__METHOD__);
  238.             gumbo_trigger ($e);
  239.         }
  240.         return false;
  241.     }
  242.     
  243.     /**
  244.      * Returns if the Report exists
  245.      * @param string $report 
  246.      * @return bool 
  247.      * @throws Gumbo_Exception
  248.      */
  249.     public function exists ($report) {
  250.         try {
  251.             // verify precondition
  252.             if (!is_string ($report)) {
  253.                 throw new Gumbo_Exception ("Invalid Argument 'report:str' => {$report}:" . gettype ($report));
  254.             }
  255.             
  256.             $report = "Gumbo_Debug_Server_Report_" . str_replace ("Gumbo_Debug_Server_Report_", "", $report);
  257.             return gumbo_load ($report);
  258.         } catch (Gumbo_Exception $e) {
  259.             $e->setFunction (__METHOD__);
  260.             gumbo_trigger ($e);
  261.         }
  262.         return false;
  263.     }
  264.     
  265.     
  266.     
  267.     /**
  268.      * Returns the object as a string
  269.      * @return string 
  270.      */
  271.     public function __toString () {
  272.         return $this->fetch ();
  273.     }
  274.     
  275. }
  276.  
  277. ?>