sThread
[ class tree: sThread ] [ index: sThread ] [ all elements ]

Source for file Vari.php

Documentation is available at Vari.php

  1. <?php
  2. /**
  3.  * Common Variables of Single Thread Monitoring<br>
  4.  * File: sThread/Vari.php
  5.  *
  6.  * @category    Network
  7.  * @package     sThread
  8.  * @subpackage  sThread_CORE
  9.  * @author      JoungKyun.Kim <http://oops.org>
  10.  * @copyright   (c) 2015 OOPS.ORG
  11.  * @license     BSD License
  12.  * @version     $Id$
  13.  * @link        http://pear.oops.org/package/sThread
  14.  * @filesource
  15.  */
  16.  
  17. /**
  18.  * sThread package에서 사용하는 공통 변수와 변수 관련
  19.  * 메소드를 제공
  20.  *
  21.  * @category    Network
  22.  * @package     sThread
  23.  * @subpackage  sThread_CORE
  24.  * @author      JoungKyun.Kim <http://oops.org>
  25.  * @copyright   (c) 2015 OOPS.ORG
  26.  * @license     BSD License
  27.  * @link        http://pear.oops.org/package/sThread
  28.  */
  29. Class Vari {
  30.     // {{{ properties
  31.     /**#@+
  32.      * @access public
  33.      */
  34.     /**
  35.      * 세션 관련 정보 저장
  36.      * @var    stdClass 
  37.      */
  38.     static public $sess;
  39.     /**
  40.      * 옵션값 저장
  41.      * @var    stdClass 
  42.      */
  43.     static public $opt;
  44.     /**
  45.      * 처리 결과값을 저장
  46.      * @var    stdClass 
  47.      */
  48.     static public $res;
  49.     /**
  50.      * 처리 시간 정보
  51.      * @var    stdClass 
  52.      */
  53.     static public $time;
  54.     /**
  55.      * Action의 결과를 반환 받을 것인지 여부
  56.      * @var    boolean 
  57.      *
  58.      */
  59.     static public $result;
  60.     /**#@-*/
  61.  
  62.     const DEBUG1 1;
  63.     const DEBUG2 2;
  64.     const DEBUG3 3;
  65.  
  66.     //const EVENT_CONNECT     = 0;
  67.     const EVENT_ERROR_CLOSE = -1;
  68.     const EVENT_READY_SEND  0;
  69.     const EVENT_READY_RECV  1;
  70.     const EVENT_SEND_DONE   1;
  71.     const EVENT_READY_CLOSE 1000;
  72.     const EVENT_UNKNOWN     false;
  73.     // }}}
  74.  
  75.     // {{{ (void) Vari::clear ($b = false)
  76.     /**
  77.      * @access public
  78.      * @return void 
  79.      * @param  bool   (optional) true로 설정하면 필요없는 member만
  80.      *                 정리한다. false의 경우, Vari Class의 모든
  81.      *                 멤버를 초기화 한다. 기본값 false
  82.      */
  83.     static function clear ($b false{
  84.         if $b !== true )
  85.             self::objectUnset (self::$res);
  86.         self::objectUnset (self::$sess);
  87.         self::objectUnset (self::$time);
  88.  
  89.         if $b !== true {
  90.             Vari::$res = (object) array (
  91.                 'total'   => 0,
  92.                 'success' => 0,
  93.                 'failure' => 0,
  94.                 'status'  => array ()
  95.             );
  96.         }
  97.  
  98.         Vari::$sess = (object) array (
  99.             'addr'   => array (),
  100.             'opt'    => array (),
  101.             'sock'   => array (),
  102.             'status' => array (),
  103.             'event'  => array (),
  104.             'recv'   => array ()// recieve data buffer
  105.             'send'   => array ()// socket write complete flag. set 1, complete
  106.             'ctime'  => array ()// Connection time. It can't believe! :-(
  107.             'ptime'  => array ()// Processing time
  108.             'time'   => array ()  // Total time
  109.         );
  110.  
  111.         Vari::$time = (object) array (
  112.             'cstart' => array (),
  113.             'cend'   => array (),
  114.             'pstart' => array (),
  115.             'pend'   => array ()
  116.         );
  117.     }
  118.     // }}}
  119.  
  120.     // {{{ (void) Vari::objectUnset (&$r)
  121.     /**
  122.      * 주어진 파라미터가 object 또는 array일 경우 소속
  123.      * 멤버들을 unset 시킨다.
  124.      *
  125.      * 자기 자신을 unset 하지는 못하므로, 이 함수 호출 후에
  126.      * 직접 unset을 해 줘야 한다.
  127.      *
  128.      * @access public
  129.      * @return void 
  130.      * @param  mixed unset할 array 또는 object
  131.      */
  132.     static function objectUnset (&$r{
  133.         switch (($type gettype ($r))) {
  134.             case 'object' :
  135.             case 'array' :
  136.                 foreach $r as $key => $val {
  137.                     switch (($subtype gettype ($val))) {
  138.                         case 'array' :
  139.                         case 'object' :
  140.                             if $type == 'array' {
  141.                                 self::objectUnset ($r[$key]);
  142.                                 unset ($r[$key]);
  143.                             else {
  144.                                 self::objectUnset ($r->$key);
  145.                                 unset ($r->$key);
  146.                             }
  147.                             break;
  148.                         default:
  149.                             if $type == 'array' )
  150.                                 unset ($r[$key]);
  151.                             else
  152.                                 unset ($r->$key);
  153.                     }
  154.                 }
  155.                 break;
  156.         }
  157.     }
  158.     // }}}
  159.  
  160.     // {{{ (void) Vari::objectCopy (&$r, $obj)
  161.     /**
  162.      * 2번째 파라미터에 주어진 값을 다른 메모리 주소에
  163.      * cpoy하여 1번째 변수에 할당한다.
  164.      *
  165.      * @access public
  166.      * @return void 
  167.      * @param  mixed 빈 변수
  168.      * @param  mixed 원본 변수
  169.      */
  170.     function objectCopy (&$r$obj{
  171.         switch (($type gettype ($obj))) {
  172.             case 'object' :
  173.             case 'array' :
  174.                 foreach $obj as $key => $val {
  175.                     switch (($subtype gettype ($val))) {
  176.                         case 'array' :
  177.                         case 'object' :
  178.                             if $type == 'array' {
  179.                                 $r[$keynull;
  180.                                 self::objectCopy ($r[$key]$val);
  181.                             else {
  182.                                 $r->$key null;
  183.                                 self::objectCopy ($r->$key$val);
  184.                             }
  185.                             break;
  186.                         default:
  187.                             if $type == 'array' )
  188.                                 $r[$keyself::varCopy ($val);
  189.                             else
  190.                                 $r->$key self::varCopy ($val);
  191.                     }
  192.                 }
  193.                 break;
  194.             default :
  195.                 $r self::varCopy ($val);
  196.         }
  197.     }
  198.     // }}}
  199.  
  200.     // {{{ (mixed) Vari::varCopy ($var)
  201.     /**
  202.      * 입력된 값을 다른 주소의 메모리에 copy하여 반환
  203.      *
  204.      * @access public
  205.      * @return mixed 
  206.      * @param  mixed 
  207.      */
  208.     function varCopy ($var{
  209.         return $var;
  210.     }
  211.     // }}}
  212.  
  213.     // {{{ (string) Vari::chkTime ($o, $n)
  214.     /**
  215.      * 두 microtime 의 차이를 계산
  216.      *
  217.      * @access public
  218.      * @return string 
  219.      * @param  string 먼저 측정된 microtime() 의 결과값
  220.      * @param  string 나중에 측정된 microtime() 의 결과값
  221.      * @param  int    보정할 millisencond 값
  222.      */
  223.     static function chkTime ($o$n$t 0{
  224.         $o self::hmicrotime ($o);
  225.         $n self::hmicrotime ($n);
  226.  
  227.         if $t )
  228.             $t /= 1000;
  229.         else if $t {
  230.             $t *= -1;
  231.             $t /= 1000000;
  232.             $t *= -1;
  233.         }
  234.  
  235.         $r $n $o $t;;
  236.  
  237.         #echo "############## $o\n";
  238.         #echo "############## $n\n";
  239.         #echo "############## $t\n";
  240.         #echo "############## $r\n";
  241.  
  242.         if $r )
  243.             return sprintf ('%.3f sec'$r);
  244.  
  245.         return sprintf ('%.3f msec'$r 1000);
  246.     }
  247.     // }}}
  248.  
  249.     // {{{ (string) Vari::timeCalc ($a)
  250.     /**
  251.      * 배열로 주어진 시간의 합을 반환
  252.      *
  253.      * @access public
  254.      * @return string 
  255.      * @param  array 
  256.      */
  257.     static function timeCalc ($a{
  258.         if is_array ($a) )
  259.             return '0 msec';
  260.  
  261.         $time 0;
  262.         foreach $a as $t {
  263.             if preg_match ('/(.*)[\s]+msec/'$t$matches) )
  264.                 $time += $matches[11000;
  265.             else
  266.                 $time += $matches[11000000;
  267.  
  268.         }
  269.  
  270.         if $time >= 1000000 {
  271.             $unit 'sec';
  272.             $div 1000000;
  273.         else {
  274.             $unit 'msec';
  275.             $div 1000;
  276.         }
  277.  
  278.         return sprintf ('%.3f %s'$time $div$unit);
  279.     }
  280.     // }}}
  281.  
  282.     // {{{ (string) Vari::binaryDecode ($bin, $ret = false)
  283.     /**
  284.      * binary data를 hex data로 변환
  285.      *
  286.      * @access public
  287.      * @return void|string
  288.      * @param  string binary data
  289.      * @param  boot   (optional) true로 설정하면 결과값을 반환한다.
  290.      *                 기본값을 false로 바로 출력을 한다.
  291.      */
  292.     function binaryDecode (&$bin$ret false{
  293.         $len strlen ($bin);
  294.         for $i=0$i<$len$i++ {
  295.             if ( ($i 8== )
  296.                 $r .= ( ($i 16== "\n" ' ';
  297.  
  298.             $r .= sprintf ("%02x "ord ($bin[$i]));
  299.         }
  300.  
  301.         if $ret )
  302.             echo $r "\n";
  303.  
  304.         $bin $r;
  305.     }
  306.     // }}}
  307.  
  308.     // {{{ (string) Vari::objectInit (&$obj)
  309.     /**
  310.      * 주어진 변수가 empty이거나 object가 아닐경우
  311.      * standard object로 선언한다.
  312.      *
  313.      * @access public
  314.      * @return void 
  315.      * @param  mixed 
  316.      */
  317.     static function objectInit (&$obj{
  318.         if empty ($obj|| is_object ($obj) )
  319.             $obj new stdClass;
  320.     }
  321.     // }}}
  322.  
  323.     /*
  324.      * Private methods.
  325.      */
  326.  
  327.     // {{{ private (float) Vari::hmicrotime ($t)
  328.     /**
  329.      * microtime 의 결과값을 sec로 보정
  330.      *
  331.      * @access private
  332.      * @return float 
  333.      * @param  string microtime() 의 결과 값
  334.      */
  335.     static private function hmicrotime ($t{
  336.         if preg_match ('/^([^ ]+)[ \t](.+)/'$t$matches) )
  337.             return (float) $matches[2+ (float) $matches[1];
  338.         return $t;
  339.     }
  340.     // }}}
  341. }
  342. ?>

Documentation generated on Tue, 14 May 2019 02:00:47 +0900 by phpDocumentor 1.4.4