<?php
/* This file provides the java uses wrapper for the XP framework
 * 
 * $Id$
 */

  // {{{ class JProxy
  //     Base class for all Java proxy instances
  class JProxy extends Object {
    var $_h= NULL;
  }
  // }}}

  // {{{ final class uwrp·java
  //     Stream wrapper
  class uwrp·java {
    var
      $buffer     = '',
      $offset     = 0;

    // {{{ php.Java create(string name, array arguments default array())
    //     Creates a Java proxy instance for a given name
    function &create($name, $arguments= array()) {
      $m= sizeof($arguments);
      if (0 == $m) $h= &new Java($name); else {
        $paramstr= '';
        for ($i= 0; $i < $m; $i++) {
          $paramstr.= ', $arguments['.$i.']';
        }

        $h= eval('return new Java(\''.$name.'\', '.substr($paramstr, 2).');');
      }

      if (!is_a($h, 'Java')) {
        return throw(new Exception('Could not instantiate '.$name.''));
      }

      if ($e= java_last_exception_get()) {
        return throw(uwrp·java::mapException($e));
      }
      
      return $h;
    }
    // }}}
    
    // {{{ mixed &invoke(php.Java h, string method, array arguments)
    //     Invokes a given method on a Java proxy instance
    function invoke(&$h, $method, $arguments) {
      java_last_exception_clear(); {
        $paramstr= '';
        for ($i= 0, $m= sizeof($arguments); $i < $m; $i++) {
          $paramstr.= ', $arguments['.$i.']';
        }

        $return= eval('return $h->'.$method.'('.substr($paramstr, 2).');');
      } if ($e= java_last_exception_get()) {
        return throw(uwrp·java::mapException($e));
      }

      if (is_a($return, 'Java')) return uwrp·java::proxyFor($return); else return $return;
    }
    // }}}
    
    // {{{ java.lang.Class classFor(string name)
    //     Returns a Java class wrapper for a given name
    function &classFor($name) {
      static $classloader= NULL;
      
      if (!$classloader) $classloader= new Java('java.lang.Class');
      $class= &$classloader->forName($name);

      if ($e= java_last_exception_get()) {
        return throw(uwrp·java::mapException($e));
      }
      return $class;
    }
    // }}}

    // {{{ lang.Throwable proxyFor(java.lang.Object instance)
    //     Returns a Java class wrapper for a given name
    function &proxyFor(&$instance) {
      $class= &$instance->getClass();
      $name= $class->getName();
      $reflect= strtr($name, '.', '·');

      class_exists($reflect) || include('java+xp://'.$name);

      return new $reflect($instance);
    }
    // }}}

    // {{{ lang.Throwable exceptionFor(java.lang.Throwable throwable)
    //     Returns an XP exception for a given Throwable instance
    function &mapException(&$throwable) {
      $class= &$throwable->getClass();
      $message= $throwable->getMessage();
      switch ($name= $class->getName()) {
        case class_exists($reflect= xp::reflect($name)): {
          $e= &new $reflect($message);
          break;
        }

        default: {
          $e= &new Exception($name.': '.$message);
        }
      }
      
      $trace= $throwable->getStackTrace();
      for ($i= 0, $m= sizeof($trace); $i < $m; $i++) {
        $e->trace[]= &new StackTraceElement(
          $trace[$i]->getFileName(),
          $trace[$i]->getClassName(),
          $trace[$i]->getMethodName(),
          $trace[$i]->getLineNumber(),
          array(),
          array()
        );
      }

      return throw($e);
    }
    // }}}

    // {{{ bool stream_open(string path, string mode, int options, &string open)
    //     Open wrapper
    function stream_open($path, $mode, $options, &$open) {
      $url= parse_url($path);
      
      // Load java class
      if (!($class= &uwrp·java::classFor($url['host']))) return FALSE;

      // Create proxy class
      $this->buffer= ('<?php class '.strtr($url['host'], '.', '·').' extends JProxy { 
        function __construct() {
          $a= func_get_args();
          if (is_a($a[0], \'Java\')) {
            $this->_h= &$a[0];
          } else {
            $this->_h= &uwrp·java::create(\''.$url['host'].'\', $a);
          }
        } '
      );

      $declared= array();
      $methods= $class->getMethods();
      for ($i= 0, $s= sizeof($methods); $i < $s; $i++) {
        $name= $methods[$i]->getName();
        if (isset($declared[$name])) continue;
        
        // Create wrapper method. The 8 in modifiers indicates static methods
        $modifiers= $methods[$i]->getModifiers();
        $this->buffer.= 'function '.$name.'() { $a= func_get_args(); return uwrp·java::invoke(';
        $this->buffer.= ($modifiers & 8) ? 'uwrp·java::create(\''.$url['host'].'\')' : '$this->_h';
        $this->buffer.= ', \''.$name.'\', $a); } ';
        $declared[$name]= TRUE;
      }

      $this->buffer.= ' } ?>';

      return TRUE;
    }
    // }}}
  
    // {{{ string stream_read(int count)
    //     Read wrapper
    function stream_read($count) {
      $chunk= substr($this->buffer, $this->offset, $count);
      $this->offset+= $count;
      return $chunk;
    }
    // }}}

    // {{{ bool stream_eof(void)
    //     EOF wrapper
    function stream_eof() {
      return $this->offset > strlen($this->buffer);
    }
    // }}}
  }
  // }}}
?>