Development of internet and intranet solutions
PDF solutions based on pure PHP

Support

Tips and Tricks

The following tips and tricks are available:

Using a pdf from a php variable instead of a file

Sometimes PDF documents are not available through the filesystem which is actually a must for all our APIs or FPDI. We belive in this solution because our APIs will just load data into memory, they really need. PDF documents could be very huge, while each PHP installation (mostly) have its memory limits - and reaching them will let the script die.

For some developers this issue isn't important, because they can adjust their memory limits as high as they want. Or other developers simply works with smal pdf documents which are saved in a blob field in a database and don't want to use temporary files in the middle of database and SetaPDF API or FPDI.

For this developers (and others) we'll describe a way, you can solve this problem with "simple" existing php features: stream wrappers

The usage of a stream wrapper will only work with FPDI > 1.2
and all other current SetaPDF APIs in their PHP 5 versions.

The PHP 4 wrapper only supports FPDI and the SetaPDF-Merger.

All other APIs are only supported if you don't do an incremental update.

PHP 4

// example is taken from here: 
// http://www.php.net/manual/en/function.stream-wrapper-register.php#77057

class GlobalStream {
    var $pos;
    var $stream;
    
    function stream_open($path, $mode, $options, &$opened_path) {
        $url = parse_url($path);
        $this->stream = &$GLOBALS[$url["host"]];
        $this->pos = 0;
        if (!is_string($this->stream)) return false;
        return true;
    }
    
    function stream_read($count) {
        $ret = substr($this->stream, $this->pos, $count);
        $this->pos += strlen($ret);
        return $ret;
    }
    
    function stream_write($data){
        $l=strlen($data);
        $this->stream =
            substr($this->stream, 0, $this->pos) .
            $data .
            substr($this->stream, $this->pos += $l);
        return $l;
    }
    
    function stream_tell() {
        return $this->pos;
    }
    
    function stream_eof() {
        return $this->pos >= strlen($this->stream);
    }
    
    function stream_seek($offset, $whence) {
        $l=strlen($this->stream);
        switch ($whence) {
            case SEEK_SET: $newPos = $offset; break;
            case SEEK_CUR: $newPos = $this->pos + $offset; break;
            case SEEK_END: $newPos = $l + $offset; break;
            default: return false;
        }
        $ret = ($newPos >=0 && $newPos <=$l);
        if ($ret) $this->pos=$newPos;
        return $ret;
    }
}

PHP 5

class GlobalStream {
    private $pos;
    private $stream;
    
    public function stream_open($path, $mode, $options, &$opened_path) {
        $url = parse_url($path);
        $this->stream = &$GLOBALS[$url["host"]];
        $this->pos = 0;
        if (!is_string($this->stream)) return false;
        return true;
    }
    
    public function stream_read($count) {
        $ret = substr($this->stream, $this->pos, $count);
        $this->pos += strlen($ret);
        return $ret;
    }
    
    public function stream_write($data){
        $l=strlen($data);
        $this->stream =
            substr($this->stream, 0, $this->pos) .
            $data .
            substr($this->stream, $this->pos += $l);
        return $l;
    }
    
    public function stream_tell() {
        return $this->pos;
    }
    
    public function stream_eof() {
        return $this->pos >= strlen($this->stream);
    }
    
    public function stream_seek($offset, $whence) {
        $l=strlen($this->stream);
        switch ($whence) {
            case SEEK_SET: $newPos = $offset; break;
            case SEEK_CUR: $newPos = $this->pos + $offset; break;
            case SEEK_END: $newPos = $l + $offset; break;
            default: return false;
        }
        $ret = ($newPos >=0 && $newPos <=$l);
        if ($ret) $this->pos=$newPos;
        return $ret;
    }

public function url_stat ($path, $flags) {
        $url = parse_url($path);
        if (isset($GLOBALS[$url["host"]])) {
            $size = strlen($GLOBALS[$url["host"]]);
            return array(
                7 => $size,
                'size' => $size
            );
        } else {
            return false;
        }
    }

public function stream_stat() {
        return array(
            'size' => strlen($this->_stream),
            7 => $size,
        );
    }
}

This class has to be registered as a stream wrapper now:

Now you can simply use the new registered wrapper this way:

Alternative PHP 5 version

Another PHP 5 version could be the following wrapper class, which doesn't rely on the $GLOBAL array:

class VarStream {
    private $_pos;
    private $_stream;
    private $_cDataIdx;

static protected $_data = array();
    static protected $_dataIdx = 0;
    
    static function createReference(&$var) {
        $idx = self::$_dataIdx++;
        self::$_data[$idx] =& $var;
        return __CLASS__.'://'.$idx;
    }

public function stream_open($path, $mode, $options, &$opened_path) {
        $url = parse_url($path);
        $cDataIdx = $url["host"];
        if (!isset(self::$_data[$cDataIdx]))
            return false;
        $this->_stream = &self::$_data[$cDataIdx];
        $this->_pos = 0;
        if (!is_string($this->_stream)) return false;
        $this->_cDataIdx = $cDataIdx;
        return true;
    }

public function stream_read($count) {
        $ret = substr($this->_stream, $this->_pos, $count);
        $this->_pos += strlen($ret);
        return $ret;
    }

public function stream_write($data){
        $l=strlen($data);
        $this->_stream =
            substr($this->_stream, 0, $this->_pos) .
            $data .
            substr($this->_stream, $this->_pos += $l);
        return $l;
    }

public function stream_tell() {
        return $this->_pos;
    }

public function stream_eof() {
        return $this->_pos >= strlen($this->_stream);
    }

public function stream_seek($offset, $whence) {
        $l=strlen($this->_stream);
        switch ($whence) {
            case SEEK_SET: $newPos = $offset; break;
            case SEEK_CUR: $newPos = $this->_pos + $offset; break;
            case SEEK_END: $newPos = $l + $offset; break;
            default: return false;
        }
        $ret = ($newPos >=0 && $newPos <=$l);
        if ($ret) $this->_pos=$newPos;
        return $ret;
    }
    
    public function stream_close() {
        unset(self::$_data[$this->_cDataIdx]);
    }
    
    public function url_stat ($path, $flags) {
        $url = parse_url($path);
        $dataIdx = $url["host"];
        if (!isset(self::$_data[$dataIdx]))
            return false;

$size = strlen(self::$_data[$dataIdx]);
        return array(
            7 => $size,
            'size' => $size
        );
    }

public function stream_stat() {
        return array(
            'size' => strlen($this->_stream),
            7 => $size,
        );
    }
}

stream_wrapper_register('VarStream', 'VarStream') or die('Failed to register protocol VarStream://');

This class can be used to access variables in any scope by simply passing the desired variable to a static method and using the return value as the URL.

Use unicode in string values