phpDocumentor OpenDocumentPHP
manifest
[ class tree: OpenDocumentPHP ] [ index: OpenDocumentPHP ] [ all elements ]
OpenDocumentPHP
Packages:
OpenDocumentPHP

Source for file ManifestDocument.php

Documentation is available at ManifestDocument.php

  1. <?php
  2.  
  3. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  4.  
  5. /*
  6.  * Created on 29. Dec. 2006 by Norman Markgraf (nmarkgraf(at)user.sourceforge.net)
  7.  */
  8.  
  9. /**
  10.  * ManifestDocument class file.
  11.  * 
  12.  * This class extends DOMDocument to fit a manifest document as it is used
  13.  * by OpenDocumentArchives to store the meta information into it.
  14.  * 
  15.  * PHP versions 5
  16.  *   
  17.  * LICENSE:
  18.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29.  *
  30.  * This software consists of voluntary contributions made by many individuals
  31.  * and is licensed under the GPL. For more information please see
  32.  * <http://opendocumentphp.org>.
  33.  * 
  34.  * $Id: ManifestDocument.php 239 2007-07-24 16:25:10Z nmarkgraf $
  35.  * 
  36.  * @category    File Formats
  37.  * @package        OpenDocumentPHP
  38.  * @subpackage    manifest
  39.  * @author         Norman Markgraf (nmarkgraf(at)user.sourceforge.net)
  40.  * @copyright     Copyright in 2006, 2007 by The OpenDocumentPHP Team
  41.  * @license     http://www.gnu.org/licenses/gpl.html GNU General Public License 2.0.
  42.  * @version        SVN: $Id: ManifestDocument.php 239 2007-07-24 16:25:10Z nmarkgraf $
  43.  * @link           http://opendocumentphp.org
  44.  * @since         0.5.0 - 08. Feb. 2007
  45.  * @todo        We need to support encryption data.
  46.  * @todo        Also we need to support the optional size part.
  47.  */
  48.  
  49. /**
  50.  * 
  51.  */
  52. require_once 'OpenDocumentPHP/util/AbstractDocument.php';
  53.  
  54. /**
  55.  * ManifestDocument class
  56.  * 
  57.  * This class extends DOMDocument to fit a manifest document as it is used
  58.  * by OpenDocumentArchives to store the meta information into it.
  59.  * 
  60.  * Example:
  61.  * <code>
  62.  *      $manifest = new ManifestDocument( 'application/vnd.oasis.opendocument.text' );
  63.  *      $manifest->addFileEntry( 'Configurations2/',
  64.  *                                  'application/vnd.sun.xml.ui.configuration' );
  65.  *      $manifest->addFileEntry( 'content.xml', 'text/xml' );
  66.  * </code>
  67.  * This code will create a manifest DOM document as follows:
  68.  * <code>
  69.  * <?xml version="1.0" encoding="UTF-8"?>
  70.  * <!DOCTYPE manifest:manifest PUBLIC "-//OpenOffice.org//DTD Manifest 1.0//EN"
  71.  *                                    "Manifest.dtd">
  72.  *  <manifest:manifest
  73.  *            xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0">
  74.  *    <manifest:file-entry
  75.  *            manifest:media-type="application/vnd.oasis.opendocument.text"
  76.  *            manifest:full-path="/"/>
  77.  *    <manifest:file-entry
  78.  *           manifest:media-type="application/vnd.sun.xml.ui.configuration"
  79.  *           manifest:full-path="Configurations2/"/>
  80.  *    <manifest:file-entry
  81.  *           manifest:media-type="text/xml"
  82.  *           manifest:full-path="content.xml"/>
  83.  *  </manifest:manifest>
  84.  * </code>
  85.  * 
  86.  * @category    File Formats
  87.  * @package        OpenDocumentPHP
  88.  * @subpackage    manifest
  89.  * @author         Norman Markgraf (nmarkgraf(at)user.sourceforge.net)
  90.  * @copyright     Copyright in 2006, 2007 by The OpenDocumentPHP Team
  91.  * @license     http://www.gnu.org/licenses/gpl.html GNU General Public License 2.0.
  92.  * @version     Release: @package_version@
  93.  * @link           http://opendocumentphp.org
  94.  * @since         0.5.0 - 08. Feb. 2007
  95.  * @todo        We need to support encryption data.
  96.  * @todo        Also we need to support the optional size part.
  97.  */
  98. class ManifestDocument extends AbstractDocument {
  99.     /** 
  100.      * Doctype information for Manifest DOM documents
  101.      */
  102.     const odmDOCTYPE = '<!DOCTYPE manifest:manifest PUBLIC "-//OpenOffice.org//DTD Manifest 1.0//EN" "Manifest.dtd">';
  103.     /**
  104.      * Root Tag for Mainifest DOM documents
  105.      */
  106.     const odmROOT = 'manifest:manifest';
  107.     /**
  108.      * Link to the DOMElement which contains the mime type.
  109.      * 
  110.      * @var DOMElement 
  111.      * @access private
  112.      */
  113.     private $mimetype;
  114.     /**
  115.      * Constructor
  116.      * 
  117.      * @param         string mimetype Mime type of the archive
  118.      * @param         string encoding Encoding of the manifest file. The default is 'UTF-8'.
  119.      * @access        public
  120.      * @since         0.5.0 - 08. Feb. 2007
  121.      */
  122.     function __construct($mimetype = '', $encoding = 'UTF-8') {
  123.         /*
  124.          * We can not use the normal way to produce a DOM document, because
  125.          * Manifest documents needs other DocType informations. So we have to go this
  126.          * way and produce a DOM document 'by hand'.
  127.          */ 
  128.         parent :: __construct();
  129.         /*
  130.          * We must use this way to ensure that we have the right encoding and doc type.
  131.          */
  132.         $this->loadXML('<?xml version="1.0" encoding="' . $encoding . '"?>' . self :: odmDOCTYPE . "\n" . '<manifest/>');
  133.         /*
  134.          * But we must change the root element, so we first remove it ...
  135.          */
  136.         $this->removeChild($this->getElementsByTagName('manifest')->item(0));
  137.         /*
  138.          * ...and now we create a new one.
  139.          * This is a hack! Please do not use createManifestElement here!
  140.          */
  141.         $this->root = $this->createElementNS(self :: MANIFEST, self :: odmROOT);
  142.         /*
  143.          * and append it to the document as new root.
  144.          */
  145.         $this->appendChild($this->root);
  146.         /*
  147.          * Add root informations. This line is part of every Manifest document.
  148.          */
  149.         $this->mimetype = $this->makeFileEntryElement('/', $mimetype);
  150.         $this->root->appendChild($this->mimetype);
  151.     }
  152.     protected function _setRoot($documentRoot = 0) {
  153.     }
  154.     /**
  155.      * Make a path string unix-aware.
  156.      * 
  157.      * @return         string A unix-aware full path.
  158.      * @param        string fullpath Normal full path.
  159.      * @access        private
  160.      * @since         0.5.0 - 08. Feb. 2007
  161.      */
  162.     private function fp($fullpath) {
  163.         return str_replace("\\", '/', $fullpath);
  164.     }
  165.     /**
  166.      * Creates a DOM element with the tag 'manifest:file-enty' and
  167.      * adds 'manifest:full-path', and 'manifest:media-type' attributes to it.
  168.      *  
  169.      * @return         DOMElement A DOM element which containt a single file entry.
  170.      * @param         string fullpath The full path of the file that has been added.
  171.      * @param         string mimetype The mime type of this file
  172.      * @param         int size The size of this file. (default: not used)
  173.      * @access        private
  174.      * @since         0.5.0 - 08. Feb. 2007
  175.      */
  176.     private function makeFileEntryElement($fullpath, $mimetype, $size = -1) {
  177.         /*
  178.          * Create a new file-entry element ...
  179.          */
  180.         $node = $this->createManifestElement('file-entry');
  181.         /*
  182.          * ... add the fullpath of the file to full-path attribute, ...
  183.          */
  184.         $node->setManifestAttribute('full-path', $this->fp($fullpath));
  185.         /*
  186.          * ... add mime type of the file into media-type attribute.
  187.          */
  188.         $node->setManifestAttribute('media-type', $mimetype);
  189.         /*
  190.          *  If a size attribute is needed, add some ...
  191.          */
  192.         if ($size >= 0) {
  193.             /*
  194.              * ... to the size attribute of the file-entry element.
  195.              */
  196.             $node->setManifestAttribute('size', $size);
  197.         }
  198.         // *** FIX ME *** - We need to handle encrypted Entrys too
  199.         return $node;
  200.     }
  201.     /**
  202.      * Add a full path to the file entry list in this manifest document.
  203.      * 
  204.      * Example:
  205.      * <code>
  206.      *     $manifest = new ManifestDocument();
  207.      *     ...
  208.      *     $manifest->addFileEntry('test/feature.xml', 'text/xml');
  209.      *     ...
  210.      * </code>
  211.      * 
  212.      * will add
  213.      * 
  214.      * <code>
  215.      *   <manifest-file-entry manifest:full-path="test/feature.xml"
  216.      *                           manifest:media-type="text/xml" />
  217.      * </code>
  218.      * 
  219.      * to the manifest DOM document.
  220.      * 
  221.      * @param         string fullpath The full path of the file that has been added.
  222.      * @param         string mimetype The mime type of this file
  223.      * @param         int size The size of this file.
  224.      * @access        public
  225.      * @since         0.5.0 - 08. Feb. 2007
  226.      */
  227.     function addFileEntry($fullpath, $mimetype, $size = -1) {
  228.         $node = $this->makeFileEntryElement($fullpath, $mimetype, $size);
  229.         // Append new file-entry node to root node        
  230.         $this->root->appendChild($node);
  231.     }
  232.     /**
  233.      * Remove a full path from this manifest document.
  234.      * 
  235.      * @param         string fullpath File to remove (given as a full path).
  236.      * @access        public
  237.      * @since         0.5.0 - 08. Feb. 2007
  238.      */
  239.     function removeFileEntry($fullpath) {
  240.         $ret = false;
  241.         $element = $this->getFileEntry($fullpath);
  242.         if ($element !== false) {
  243.             $this->root->removeChild($element);
  244.             $ret = true;
  245.         }
  246.         return $ret;
  247.     }
  248.     /**
  249.      * Get File Entry
  250.      * 
  251.      * @access        public
  252.      * @since         0.5.0 - 08. Feb. 2007
  253.      */
  254.     function getFileEntry($fullpath) {
  255.         $ret = false;
  256.         $search = $this->fp($fullpath);
  257.         foreach ($this->getElementsByTagNameNS(self :: MANIFEST, 'file-entry') as $element) {
  258.             if ($element->getAttributeNS(self :: MANIFEST, 'full-path') === $search) {
  259.                 $ret = $element;
  260.                 break;
  261.             }
  262.         }
  263.         return $ret;
  264.     }
  265.     /**
  266.      * 
  267.      * 
  268.      * @access        public
  269.      * @since         0.5.0 - 08. Feb. 2007
  270.      */
  271.     function getFilelist() {
  272.         $ret = array ();
  273.         foreach ($this->getElementsByTagNameNS(self :: MANIFEST, 'file-entry') as $element) {
  274.             $tmp = array (
  275.                 'name' => $element->getAttributeNS(self :: MANIFEST,
  276.                 'full-path'
  277.             ), 'media-type' => $element->getAttributeNS(self :: MANIFEST, 'media-type'));
  278.             if ($element->hasAttributeNS(self :: MANIFEST, 'size') === true) {
  279.                 $tmp['manifest_size'] = $element->getAttributeNS(self :: MANIFEST, 'size');
  280.             }
  281.             $ret[] = $tmp;
  282.         }
  283.         return $ret;
  284.     }
  285.     /**
  286.      * Rename a file name entry in this manifest document.
  287.      * 
  288.      * @param         string fullpath Old file name (as a full path).
  289.      * @param         string newfullpath New file name (as a full path).
  290.      * @access        public
  291.      * @since         0.5.0 - 08. Feb. 2007
  292.      */
  293.     function renameFileEntry($fullpath, $newfullpath) {
  294.         $ret = false;
  295.         if ($fullpath != $newfullpath) {
  296.             $element = $this->getFileEntry($fullpath);
  297.             if ($element !== false) {
  298.                 $element->removeAttributeNS(self :: MANIFEST, 'full-path');
  299.                 $element->setAttributeNS(self :: MANIFEST, 'manifest:full-path', $this->fp($newfullpath));
  300.                 $ret = true;
  301.             }
  302.         }
  303.         return $ret;
  304.     }
  305.     /**
  306.      * Set mime type of the archive.
  307.      * 
  308.      * @param         string mimetype New mime type of this archive.
  309.      * @access        public
  310.      * @since         0.5.0 - 08. Feb. 2007
  311.      */
  312.     function setMimeType($mimetype) {
  313.         /*
  314.          * First we remove the old media-type attribute ...
  315.          */
  316.         $this->mimetype->removeAttributeNS(self :: MANIFEST, 'media-type');
  317.         /*
  318.          * ... and now we can add the new mimetype to the media-type attribute.
  319.          */
  320.         $this->mimetype->setAttributeNS(self :: MANIFEST, 'media-type', $mimetype);
  321.     }
  322.     /**
  323.      * Returns mime type of the archive.
  324.      * 
  325.      * @return         string Mime type of this archive
  326.      * @access        public
  327.      * @since         0.5.0 - 08. Feb. 2007
  328.      */
  329.     function getMimeType() {
  330.         return $this->mimetype->getAttributeNS(self :: MANIFEST, 'media-type');
  331.     }
  332.     /**
  333.      * Reads MimeType out of the current DOM document.
  334.      * 
  335.      * @access        private
  336.      * @since         0.5.0 - 08. Feb. 2007
  337.      */
  338.     private function readMimeType() {
  339.         $this->mimetype = $this->getFileEntry('/');
  340.     }
  341.     /**
  342.      * Setup root of the DOM document.
  343.      * 
  344.      * @access        private
  345.      * @since         0.5.0 - 08. Feb. 2007
  346.      */
  347.     private function setupRoot() {
  348.         $this->root = $this->getElementsByTagNameNS(self :: MANIFEST, 'manifest')->item(0);
  349.     }
  350.     /**
  351.      * Loads an XML document from a string.
  352.      * This method may also be called statically to load and create a
  353.      * <i>ManifestDocument</i> object. The static invocation may be used when no
  354.      * <i>ManifestDocument</i> properties need to be set prior to loading.
  355.      * 
  356.      * @param         string source The string containing the XML.
  357.      * @return         boolean 
  358.      * @access        public
  359.      * @since         0.5.0 - 08. Feb. 2007
  360.      */
  361.     function loadXML($source, $options = 0) {
  362.         $ret = parent :: loadXML($source, $options);
  363.         $this->readMimeType();
  364.         $this->setupRoot();
  365.         return $ret;
  366.     }
  367.     /**
  368.      * Loads an XML document from a file.
  369.      * 
  370.      * This method may also be called statically to load and create a
  371.      * <i>DOMDocument</i> object. The static invocation may be used when no
  372.      * <i>ManifestDocument</i> properties need to be set prior to loading.
  373.      *  
  374.      * @param         string filename The path to the XML document.
  375.      * @param         int options
  376.      * @access        public
  377.      * @since         0.5.0 - 08. Feb. 2007
  378.      */
  379.     function load($filename, $options = 0) {
  380.         $ret = parent :: load($filename, $options);
  381.         $this->readMimeType();
  382.         $this->setupRoot();
  383.         return $ret;
  384.     }
  385. }
  386. ?>
Documentation generated on Wed, 18 Jun 2008 06:29:28 +0200 by phpDocumentor 1.3.2