classes/class.ilXmlWriter.php

Go to the documentation of this file.

<?php

/*
    +-----------------------------------------------------------------------------+
    | ILIAS open source                                                           |
        +-----------------------------------------------------------------------------+
    | Copyright (c) 1998-2001 ILIAS open source, University of Cologne            |
    |                                                                             |
    | This program is free software; you can redistribute it and/or               |
    | modify it under the terms of the GNU General Public License                 |
    | as published by the Free Software Foundation; either version 2              |
    | of the License, or (at your option) any later version.                      |
    |                                                                             |
    | This program is distributed in the hope that it will be useful,             |
    | but WITHOUT ANY WARRANTY; without even the implied warranty of              |
    | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               |
    | GNU General Public License for more details.                                |
    |                                                                             |
    | You should have received a copy of the GNU General Public License           |
    | along with this program; if not, write to the Free Software                 |
    | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. |
    +-----------------------------------------------------------------------------+
*/

class ilXmlWriter
{
        var $xmlStr;

        var $version;

        var $outEnc;

        var $inEnc;

        var $dtdDef = "";

        var $stSheet = "";

        var $genCmt = "Generated by ILIAS XmlWriter";

        function ilXmlWriter ($version = "1.0", $outEnc = "utf-8", $inEnc = "utf-8")
        {
                // initialize xml string
                $this->xmlStr = "";
                
                // set properties
                $this->version = $version;
                $this->outEnc = $outEnc;
                $this->inEnc = $inEnc;
        }
        
        function _ilXmlWriter ()
        {
                // terminate xml string
                unset($this->xmlStr);
        }
        
        function xmlSetDtdDef ($dtdDef)
        {
                $this->dtdDef = $dtdDef;
        }
        
        function xmlSetStSheet ($stSheet)
        {
                $this->stSheet = $stSheet;
        }
        
        function xmlSetGenCmt ($genCmt)
        {
                $this->genCmt = $genCmt;
        }

        function _xmlEscapeData($data)
        {
                $position = 0;
                $length = strlen($data);
                $escapedData = "";
                
                for(; $position < $length;)
                {
                        $character = substr($data, $position, 1);
                        $code = Ord($character);
                        
                        switch($code)
                        {
                                case 34:
                                        $character = "&quot;";
                                        break;
                                
                                case 38:
                                        $character = "&amp;";
                                        break;
                                
                                case 39:
                                        $character = "&apos;";
                                        break;
                                
                                case 60:
                                        $character = "&lt;";
                                        break;
                                
                                case 62:
                                        $character = "&gt;";
                                        break;
                                
                                default:
                                        if ($code < 32)
                                        {
                                                $character = ("&#".strval($code).";");
                                        }
                                        break;
                        }
                        
                        $escapedData .= $character;
                        $position ++;
                }
                return $escapedData;
        }
        
        function xmlEncodeData($data)
        {
                if ($this->inEnc == $this->outEnc)
                {
                        $encodedData = $data;
                }
                else
                {
                        switch(strtolower($this->outEnc))
                        {
                                case "utf-8":
                                        if(strtolower($this->inEnc) == "iso-8859-1")
                                        {
                                                $encodedData = utf8_encode($data);
                                        }
                                        else
                                        {
                                                die ("<b>Error</b>: Cannot encode iso-8859-1 data in ".$this->outEnc.
                                                                " in <b>".__FILE__."</b> on line <b>".__LINE__."</b><br />");
                                        }
                                        break;
                                
                                case "iso-8859-1":
                                        if(strtolower($this->inEnc) == "utf-8")
                                        {
                                                $encodedData = utf8_decode($data);
                                        }
                                        else
                                        {
                                                die ("<b>Error</b>: Cannot encode utf-8 data in ".$this->outEnc.
                                                                " in <b>".__FILE__."</b> on line <b>".__LINE__."</b><br />");
                                        }
                                        break;
                                        
                                default:
                                        die ("<b>Error</b>: Cannot encode ".$this->inEnc." data in ".$this->outEnc.
                                                        " in <b>".__FILE__."</b> on line <b>".__LINE__."</b><br />");
                        }
                }
                return $encodedData;
        }
        
        function xmlFormatData($data)
        {
                // regular expression for tags
                $formatedXml = preg_replace_callback("|<[^>]*>[^<]*|", array($this, "xmlFormatElement"), $data);
                
                return $formatedXml;
        }
        
        function xmlFormatElement($array)
        {
                $found = trim($array[0]);
                
                static $indent;
                
                // linebreak (default)
                $nl = "\n";
                
                $tab = str_repeat(" ", $indent * 2);
                
                // closing tag
                if (substr($found, 0, 2) == "</")
                {
                        if($indent)
                        {
                                $indent --;
                        }
                        $tab = str_repeat(" ", $indent * 2);
                }
                elseif (substr($found, -2, 1) == "/" or // opening and closing, comment, ...
                                strpos($found, "/>") or
                                substr($found, 0, 2) == "<!") 
                {
                        // do not change indent
                }
                elseif (substr($found, 0, 2) == "<?") 
                {
                        // do not change indent
                        // no linebreak
                        $nl = "";
                }
                else // opening tag
                {
                        $indent ++;
                }
                
                // content
                if (substr($found, -1) != ">")
                {
                        $found = str_replace(">", ">\n".str_repeat(" ", ($indent + 0) * 2), $found);
                }
                
                return $nl.$tab.$found;
        }
        
        function xmlHeader()
        {
                // version and encoding
                $this->xmlStr .= "<?xml version=\"".$this->version."\" encoding=\"".$this->outEnc."\"?>";
                
                // dtd definition
                if ($this->dtdDef <> "")
                {
                        $this->xmlStr .= $this->dtdDef;
                }
                
                // stSheet
                if ($this->stSheet <> "")
                {
                        $this->xmlStr .= $this->stSheet;
                }
                
                // generated comment
                if ($this->genCmt <> "")
                {
                        $this->xmlComment($this->genCmt);
                }
                
                return $xmlStr;
        }
        
        function xmlStartTag ($tag, $attrs = NULL, $empty = FALSE, $encode = TRUE, $escape = TRUE)
        {
                // write first part of the starttag
                $this->xmlStr .= "<".$tag;
                
                // check for existing attributes
                if (is_array($attrs))
                {
                        // write attributes
                        foreach ($attrs as $name => $value)
                        {
                                // encode
                                if ($encode)
                                {
                                $value = $this->xmlEncodeData($value);
                                }
                                
                                // escape
                                if ($escape)
                                {
                                        $value = ilXmlWriter::_xmlEscapeData($value);
                        }
                                
                                $this->xmlStr .= " ".$name."=\"".$value."\"";
                        }
                }
                
                // write last part of the starttag
                if ($empty)
                {
                        $this->xmlStr .= "/>";
                }
                else
                {
                        $this->xmlStr .= ">";
                }
        }
        
        function xmlEndTag ($tag)
        {
                $this->xmlStr .= "</".$tag.">";
        }
        
        function xmlComment ($comment)
        {
                $this->xmlStr .= "<!--".$comment."-->";
        }

        function xmlData ($data, $encode = TRUE, $escape = TRUE)
        {
                // encode
                if ($encode)
                {
                    $data = $this->xmlEncodeData($data);
                }
                
                // escape
                if ($escape)
                {
                        $data = ilXmlWriter::_xmlEscapeData($data);
            }
                
                $this->xmlStr .= $data;
        }
        
        function xmlElement ($tag, $attrs = NULL, $data = Null, $encode = TRUE, $escape = TRUE)
        {
                // check for existing data (element's content)
                if (is_string($data) or
                        is_integer($data))
                {
                        // write starttag
                        $this->xmlStartTag($tag, $attrs, FALSE, $encode, $escape);
                        
                        // write text
                        $this->xmlData($data, $encode, $escape);
                        
                        // write endtag
                        $this->xmlEndTag($tag);
                }
                else // no data
                {
                        // write starttag (= empty tag)
                        $this->xmlStartTag($tag, $attrs, TRUE, $encode, $escape);
                }
        }
        
        function xmlDumpFile($file, $format = TRUE)
        {
                // open file
                if (!($fp = @fopen($file,"w+")))
                {
                        die ("<b>Error</b>: Could not open \"".$file."\" for writing".
                                        " in <b>".__FILE__."</b> on line <b>".__LINE__."</b><br />");
                }
                
                // set file permissions
                chmod($file, 0770);
                
                // format xml data
                if ($format)
                {
                        $xmlStr = $this->xmlFormatData($this->xmlStr);
                }
                else
                {
                        $xmlStr = $this->xmlStr;
                }
                
                // write xml data into the file
                fwrite($fp, $xmlStr);
                
                // close file
                fclose($fp);
        }
        
        function xmlDumpMem($format = TRUE)
        {
                // format xml data
                if ($format)
                {
                        $xmlStr = $this->xmlFormatData($this->xmlStr);
                }
                else
                {
                        $xmlStr = $this->xmlStr;
                }
                
                return $xmlStr;
        }

        function appendXML($a_str)
        {
                $this->xmlStr .= $a_str;
        }
        
        function xmlClear ()
        {
                // reset xml string
                $this->xmlStr = "";
        }

}

?>