<?PHP

  /**
   * phOSCAR
   * -------
   * An OSCAR-Implementation in PHP 5
   * 
   * This work is distributed within the terms of
   * creative commons attribution-share alike 3.0 germany
   * 
   * See http://creativecommons.org/licenses/by-sa/3.0/ for more information
   * 
   * @author Bernd Holzmueller <bernd@tiggerswelt.net>
   * @revision 03
   * @license http://creativecommons.org/licenses/by-sa/3.0/de/ Creative Commons Attribution-Share Alike 3.0 Germany
   * @homepage http://oss.tiggerswelt.net/oscar/
   * @copyright Copyright &copy; 2009 tiggersWelt.net 
   */
                                               
  /**
   * Common functions for OSCAR Implementation
   * 
   * @class OSCAR_Common
   * @package OSCAR
   * @author Bernd Holzmueller <bernd@tiggerswelt.net>
   * @version 0.1
   */
  class OSCAR_Common {
    // {{{ str2int
    /**
     * Convert a variable-length string to an integer
     * 
     * @param string $Data String to convert
     * @param bool $Truncate (optional)
     * @param int $Start (optional)
     * @param int $Length (optional)
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @retrun int
     */
    public static function str2int (&$Data, $Truncate = false, $Start = null, $Length = null, $LE = false) {
      $l = strlen ($Data);
      
      if ($Start < 0)
        $Start = 0;
      
      if ($Length < 1)
        $Length = $l;
      else
        $Length = min ($Length, $l - $Start);
      
      $Value = substr ($Data, $Start, $Length);
      $out = 0;
      
      if ($LE)
        for ($i = 0; $i < $Length / 2; $i++) {
          $t = $Value [$i];
          $l = $Length - $i - 1;
          $Value [$i] = $Value [$l];
          $Value [$l] = $t;
        }
      
      for ($i = 0; $i < $Length; $i++)
        $out = ($out << 8) + ord ($Value [$i]);
      
      if ($Truncate)
        $Data = substr ($Data, 0, $Start) . substr ($Data, $Start + $Length);
      
      return $out;
    }
    // }}}
    
    // {{{ str2int8
    /**
     * Convert a string to an 8-bit integer
     * 
     * @param string $Data String to convert
     * @param int $Offset (optional) Where to start in string
     * @param bool $Truncate (optional)
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return int
     * @see str2int
     */
    public static function str2int8 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      return self::str2int ($Data, $Truncate, $Offset, 1, $LE);
    }
    // }}}
    
    // {{{ str2int16
    /**
     * Convert a string to an 16-bit integer
     * 
     * @param string $Data String to convert
     * @param int $Offset (optional) Where to start in string
     * @param bool $Truncate (optional)
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return int 
     * @see str2int
     */
    public static function str2int16 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      return self::str2int ($Data, $Truncate, $Offset, 2, $LE);
    }
    // }}}
    
    // {{{ str2int32
    /**
     * Convert a string to an 32-bit integer
     * 
     * @param string $Data String to convert
     * @param int $Offset (optional) Where to start in string
     * @param bool $Truncate (optional)
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return int 
     * @see str2int
     */
    public static function str2int32 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      return self::str2int ($Data, $Truncate, $Offset, 4, $LE);
    }
    // }}}
    
    // {{{ str2int64
    /**
     * Convert a string to an 64-bit integer
     * 
     * @param string $Data String to convert
     * @param int $Offset (optional) Where to start in string
     * @param bool $Truncate (optional)
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return int 
     * @see str2int
     */
    public static function str2int64 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      return self::str2int ($Data, $Truncate, $Offset, 8, $LE);
    }
    // }}}
    
    // {{{ string08
    /**
     * Handle OSCAR string08-type
     * 
     * @param stirng $Data String to convert
     * @param int $Offset (optional) Where to start
     * @param bool $Truncate (optional) Truncate data from string
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return string
     */
    public function string08 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      $Length = self::str2int8 ($Data, $Offset, false, $LE);
      $rc = substr ($Data, $Offset + 1, $Length);
      
      if ($Truncate)
        $Data = substr ($Data, 0, $Offset) . substr ($Data, $Offset + $Length + 1);
      
      return $rc;
    }
    // }}}
    
    // {{{ string16
    /**
     * Handle OSCAR string16-type
     * 
     * @param stirng $Data String to convert
     * @param int $Offset (optional) Where to start
     * @param bool $Truncate (optional) Truncate data from string
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return string
     */
    public function string16 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      $Length = self::str2int16 ($Data, $Offset, false, $LE);
      $rc = substr ($Data, $Offset + 2, $Length);
       
      if ($Truncate) 
        $Data = substr ($Data, 0, $Offset) . substr ($Data, $Offset + $Length + 2);
      
      return $rc;
    }
    // }}}
    
    // {{{ string16
    /**
     * Handle OSCAR string32-type
     * 
     * @param stirng $Data String to convert
     * @param int $Offset (optional) Where to start
     * @param bool $Truncate (optional) Truncate data from string
     * @param bool $LE (optional) Treat as little endian
     * 
     * @access public
     * @return string
     */
    public function string32 (&$Data, $Offset = 0, $Truncate = false, $LE = false) {
      $Length = self::str2int32 ($Data, $Offset, false, $LE);
      $rc = substr ($Data, $Offset + 4, $Length);
       
      if ($Truncate)
        $Data = substr ($Data, 0, $Offset) . substr ($Data, $Offset + $Length + 4);
      
      return $rc;
    }
    // }}}
    
    // {{{ toString08
    /**
     * Convert a string to string08-type
     * 
     * @param string $Data
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return string
     */
    public function toString08 ($Data, $LE = false) {
      return OSCAR_Common::int8tostr (strlen ($Data), $LE) . $Data;
    }
    // }}}
    
    // {{{ toString16
    /**
     * Convert a string to string16-type
     * 
     * @param string $Data
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return string
     */
    public function toString16 ($Data, $LE = false) {
      return OSCAR_Common::int16tostr (strlen ($Data), $LE) . $Data;
    }
    // }}}
    
    // {{{ toString32
    /**
     * Convert a string to string32-type
     * 
     * @param string $Data
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return string
     */
    public function toString32 ($Data, $LE = false) {
      return OSCAR_Common::int32tostr (strlen ($Data), $LE) . $Data;
    }
    // }}}
    
    // {{{ GUID
    /** 
     * Retrive a binary GUID
     * 
     * @param string $Data String to Convert
     * @param int $Offset (optional) Where to start
     * @param bool $Truncate (optional) Truncate data from string
     * 
     * @access public
     * @return string
     */
    public static function GUID (&$Data, $Offset = 0, $Truncate = false) {
      $GUID = substr ($Data, $Offset, 16);
      
      if ($Truncate)
        $Data = substr ($Data, 0, $Offset) . substr ($Data, $Offset + 16);
      
      return $GUID;
    }
    // }}}
    
    // {{{ toGUID
    /**
     * Covert a "normal" GUID-String to its binary representation
     * 
     * @param string $Data
     * 
     * @access public
     * @return string
     **/
    public static function toGUID ($Data) {
      // Strip everything unneccessary first
      $buf = str_replace (array (" ", "-", "{", "}"), array ("", "", "", ""), $Data);
      $Capa = "";
       
      for ($i = 0; $i < strlen ($buf) / 2; $i++)
        $Capa .= chr (hexdec (substr ($buf, $i * 2, 2)));
      
      return $Capa;
    }
    // }}}
    
    // {{{ int2str
    /**
     * Convert an integer to a string
     * 
     * @param int $Value Integer to convert
     * @param int $Width (optional) Force Output of n bytes
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return string
     */
    public static function int2str ($Value, $Width = null, $LE = false) {
      $out = "";
      
      while ($Value > 0) {
        $out = ($LE ? $out : "") . chr ($Value % 256) . ($LE ? "" : $out);
        $Value /= 256;
      }
      
      if (($Width <= 0) || (strlen ($out) == $Width))
        return $out;
      
      while (strlen ($out) < $Width)
        $out = ($LE ? $out : "") . chr (0) . ($LE ? "" : $out);
      
      if ($LE)
        return substr ($out, 0, $Width);
      else
        return substr ($out, strlen ($out) - $Width, $Width);
    }
    // }}}
    
    // {{{ int8tostr
    /**
     * Convert a 8-bit Integer into a string
     * 
     * @param int $Value
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return stirng
     * @see int2str
     */
    public static function int8tostr ($Value, $LE = false) {
      return self::int2str ($Value, 1, $LE);
    }
    // }}}
    
    // {{{ int16tostr
    /**
     * Convert a 16-bit Integer into a string
     * 
     * @param int $Value
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return stirng
     * @see int2str
     */
    public static function int16tostr ($Value, $LE = false) {
      return self::int2str ($Value, 2, $LE);
    }
    // }}}
    
    // {{{ int32tostr
    /**
     * Convert a 32-bit Integer into a string
     * 
     * @param int $Value
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return stirng
     * @see int2str  
     */
    public static function int32tostr ($Value, $LE = false) {
      return self::int2str ($Value, 4, $LE);
    }
    // }}}
    
    // {{{ int64tostr
    /**
     * Convert a 64-bit Integer into a string
     * 
     * @param int $Value
     * @param bool $LE (optional) Output in little endian
     * 
     * @access public
     * @return stirng
     * @see int2str  
     */
    public static function int64tostr ($Value, $LE = false) {
      return self::int2str ($Value, 8, $LE);
    }
    // }}}
  }
  
  

?>