ProcessorXML.php

Go to the documentation of this file.

<?php


class ProcessorXML
{
  private $dom;

  private $prefixes = array();

  function __construct()
  {
    $this->dom = new DomDocument("1.0", "utf-8");
  }

  function __destruct(){}

  function createResultset()
  {
    $resultset = $this->dom->createElement("resultset");

    return ($resultset);
  }

  function createSubject($type, $uri = "")
  {
    $subject = $this->dom->createElement("subject");

    // The TYPE attribute
    $type_attr = $this->dom->createAttribute("type");
    $type_attr_value = $this->dom->createTextNode($this->xmlEncode($type));

    $subject->appendChild($type_attr);
    $type_attr->appendChild($type_attr_value);

    // The URI attribute
    $uri_attr = $this->dom->createAttribute("uri");
    $uri_attr_value = $this->dom->createTextNode($this->xmlEncode($uri));

    $subject->appendChild($uri_attr);
    $uri_attr->appendChild($uri_attr_value);

    return $subject;
  }

  function createPrefix($entity, $uri)
  {
    $prefix = $this->dom->createElement("prefix");

    // The TYPE attribute
    $prefix_attr = $this->dom->createAttribute("entity");
    $prefix_attr_value = $this->dom->createTextNode($entity);

    $prefix->appendChild($prefix_attr);
    $prefix_attr->appendChild($prefix_attr_value);

    // The URI attribute
    $uri_attr = $this->dom->createAttribute("uri");
    $uri_attr_value = $this->dom->createTextNode($uri);

    $prefix->appendChild($uri_attr);
    $uri_attr->appendChild($uri_attr_value);

    return $prefix;
  }

  function createPredicate($type)
  {
    $predicate = $this->dom->createElement("predicate");

    // The TYPE attribute
    $type_attr = $this->dom->createAttribute("type");
    $type_attr_value = $this->dom->createTextNode($this->xmlEncode($type));

    $predicate->appendChild($type_attr);
    $type_attr->appendChild($type_attr_value);

    return $predicate;
  }

  function createObject($type, $uri, $label = "")
  {
    $object = $this->dom->createElement("object");

    // The TYPE attribute
    if ($type != "")
    {
      $type_attr = $this->dom->createAttribute("type");
      $type_attr_value = $this->dom->createTextNode($this->xmlEncode($type));

      $object->appendChild($type_attr);
      $type_attr->appendChild($type_attr_value);
    }

    // The URI attribute
    $uri_attr = $this->dom->createAttribute("uri");
    $uri_attr_value = $this->dom->createTextNode($this->xmlEncode($uri));

    $object->appendChild($uri_attr);
    $uri_attr->appendChild($uri_attr_value);

    if ($label != "")
    {
      // The LABEL attribute
      $label_attr = $this->dom->createAttribute("label");
      $label_attr_value = $this->dom->createTextNode($this->xmlEncode($label));

      $object->appendChild($label_attr);
      $label_attr->appendChild($label_attr_value);
    }

    return $object;
  }

  function createObjectContent($content)
  {
    $objectContent = $this->dom->createElement("object", $this->xmlEncode($content));

    // The TYPE attribute
    $type_attr = $this->dom->createAttribute("type");
    $type_attr_value = $this->dom->createTextNode("rdfs:Literal");

    $objectContent->appendChild($type_attr);
    $type_attr->appendChild($type_attr_value);

    return $objectContent;
  }


  function createReificationStatement($type, $value)
  {
    $reify = $this->dom->createElement("reify");

    // The TYPE attribute
    $type_attr = $this->dom->createAttribute("type");
    $type_attr_value = $this->dom->createTextNode($this->xmlEncode($type));

    $reify->appendChild($type_attr);
    $type_attr->appendChild($type_attr_value);

    // The VALUE attribute
    $value_attr = $this->dom->createAttribute("value");
    $value_attr_value = $this->dom->createTextNode($this->xmlEncode($value));

    $reify->appendChild($value_attr);
    $value_attr->appendChild($value_attr_value);

    return $reify;
  }

  function saveXML($resultset)
  {
    $this->dom->appendChild($resultset);

    $this->dom->formatOutput = true;

    return $this->dom->saveXML();
  }

  function loadXML($xml_doc)
  {
    // Get all prefixes for this XML document.
    $prefixPos = 0;

    while (($prefixPos = stripos($xml_doc, "<prefix", $prefixPos)) !== FALSE)
    {
      $entityPosStart = stripos($xml_doc, 'entity="', $prefixPos);
      $entityPosEnd = stripos($xml_doc, '"', $entityPosStart + 9);
      $entity = substr($xml_doc, $entityPosStart + 8, ($entityPosEnd - $entityPosStart - 8));

      $uriPosStart = stripos($xml_doc, 'uri="', $entityPosEnd);
      $uriPosEnd = stripos($xml_doc, '"', $uriPosStart + 6);
      $uri = substr($xml_doc, $uriPosStart + 5, ($uriPosEnd - $uriPosStart - 5));

      $prefixPos = $uriPosEnd;

      $this->prefixes[$entity] = $uri;
    }

    // Now lets resolve all prefixes in the XML file.

    $replace = array();
    $replaceFor = array();

    foreach ($this->prefixes as $prefix => $uri)
    {
      array_push($replace, "type=\"$prefix:");
      array_push($replaceFor, "type=\"$uri");
    }

    $xml_doc = str_ireplace($replace, $replaceFor, $xml_doc);

    $this->dom->loadXML($xml_doc);
  }

  function createResultsetFromElement(&$element)
  {
    if(get_class($element) != "DOMElement ")
    {
      $dom = new DomDocument("1.0", "utf-8");
      $resultset = $dom->appendChild($dom->createElement("resultset"));

      $domNode = $dom->importNode($element, true);
      $resultset->appendChild($domNode);

      $dom->formatOutput = true;

      return ($dom);
    }

    return (NULL);
  }
  function appendElementToRoot(&$element)
  {
    $domNode = $this->dom->importNode($element, true);
    $this->dom->documentElement->appendChild($domNode);
  }

  function importNode(&$targetElement, $importElement)
  {
    if(($targetElement != null && (get_class($targetElement) == "DOMNode" ||
                                   get_class($targetElement) == "DOMElement")) && 
       ($importElement != null && (get_class($importElement) == "DOMNode" ||
                                   get_class($importElement) == "DOMElement"))) 
    {
      $domNode = $this->dom->importNode($importElement, true);
      $targetElement->appendChild($domNode);
    }
  }


  function getSubjectsByType($type)
  {
    $type = $this->transformPrefix($type);

    $xpath = new DOMXPath($this->dom);

    $query = '//resultset/subject[attribute::type="' . $type . '"]';

    $subjects = $xpath->query($query);

    return ($subjects);
  }

  function transformPrefix($type)
  {
    if (strpos($type, ":") !== FALSE)
    {
      foreach ($this->prefixes as $entity => $uri)
      {
        if (stripos($type, $entity . ":") !== FALSE)
        {
          return (str_replace($entity . ":", $uri, $type));
        }
      }
    }

    return $type;
  }


  function getSubjects()
  {
    $xpath = new DOMXPath($this->dom);

    $query = '//resultset/subject';

    $subjects = $xpath->query($query);

    return($subjects);
  }

  function getPrefixes()
  {
    $xpath = new DOMXPath($this->dom);

    $query = '//resultset/prefix';

    $prefixes = $xpath->query($query);

    return ($prefixes);
  }

  function getSubjectContent(&$subject){}


  function getXPath($xpath)
  {
    $xpath = $this->transformPrefix($xpath);

    $xpath_path = new DOMXPath($this->dom);

    $nodes = $xpath_path->query($xpath);

    return ($nodes);
  }


  function getPredicatesByType(&$subject, $type)
  {
    if($subject != null && (get_class($subject) == "DOMNode" ||
                            get_class($subject) == "DOMElement")) 
    {
      $type = $this->transformPrefix($type);

      $xpath = new DOMXPath($this->dom);

      $query = './/predicate[attribute::type="' . $type . '"]';

      $predicates = $xpath->query($query, $subject);

      return($predicates);
    }
    
    return(new DOMNodeList()); 
  }
  
  function getPredicates(&$subject)
  {
    if($subject != null && (get_class($subject) == "DOMNode" ||
                            get_class($subject) == "DOMElement")) 
    {
      $xpath = new DOMXPath($this->dom);

      $query = './/predicate';

      $predicates = $xpath->query($query, $subject);

      return ($predicates);
    }
    
    return(new DOMNodeList()); 
  }

  function getObjectsByType(&$predicate, $type)
  {
    if($predicate != null && (get_class($predicate) == "DOMNode" ||
                              get_class($predicate) == "DOMElement")) 
    {
      $type = $this->transformPrefix($type);

      $xpath = new DOMXPath($this->dom);

      $query = './/object[attribute::type="' . $type . '"]';

      $objects = $xpath->query($query, $predicate);

      return ($objects);
    }
    else
    {
      return(new DOMNodeList()); 
    }
  }

  function getObjects(&$predicate)
  {
    if($predicate != null && (get_class($predicate) == "DOMNode" ||
                              get_class($predicate) == "DOMElement")) 
    {
      $xpath = new DOMXPath($this->dom);

      $query = './/object';

      $objects = $xpath->query($query, $predicate);

      return ($objects);
    }
    
    return(new DOMNodeList()); 
  }

  function getReificationStatementsByType(&$object, $type)
  {
    if($object != null && (get_class($object) == "DOMNode" ||
                           get_class($object) == "DOMElement")) 
    {
      $type = $this->transformPrefix($type);

      $xpath = new DOMXPath($this->dom);

      $query = './/reify[attribute::type="' . $type . '"]';

      $reifies = $xpath->query($query, $object);

      return ($reifies);
    }
    
    return(new DOMNodeList()); 
  }

  function getReificationStatements(&$object)
  {
    if($object != null && (get_class($object) == "DOMNode" ||
                           get_class($object) == "DOMElement")) 
    {
      $xpath = new DOMXPath($this->dom);
    
      $query = './/reify';
      
      $reifies = $xpath->query($query, $object);
      
      return ($reifies);
    }
    
    return(new DOMNodeList()); 
  }

  function getURI(&$node)
  {
    if($node != null && (get_class($node) == "DOMNode" ||
                         get_class($node) == "DOMElement")) 
    {
      if (isset($node->attributes))
      {
        return ($node->attributes->getNamedItem("uri")->nodeValue);
      }
    }
    
    return "";
  }

  function getEntity(&$node)
  {
    if($node != null && (get_class($node) == "DOMNode" ||
                         get_class($node) == "DOMElement")) 
    {    
      if(isset($node->attributes))
      {
        return ($node->attributes->getNamedItem("entity")->nodeValue);
      }
    }
    return "";
  }


  function getLabel(&$node)
  {
    if($node != null && (get_class($node) == "DOMNode" ||
                         get_class($node) == "DOMElement")) 
    {    
      if (isset($node->attributes))
      {
        return ($node->attributes->getNamedItem("label")->nodeValue);
      }
    }
    
    return "";
  }

  function getValue(&$node)
  {
    if($node != null && (get_class($node) == "DOMNode" ||
                         get_class($node) == "DOMElement")) 
    {
      if (isset($node->attributes))
      {
        return ($node->attributes->getNamedItem("value")->nodeValue);
      }
    }
    
    return "";
  }

  function getType(&$node, $prefixed = TRUE)
  {
    if($node != null && (get_class($node) == "DOMNode" ||
                         get_class($node) == "DOMElement")) 
    {
      if (isset($node->attributes))
      {
        if ($prefixed === TRUE)
        {
          foreach ($this->prefixes as $entity => $uri)
          {
            if (stripos($node->attributes->getNamedItem("type")->nodeValue, $uri) !== FALSE)
            {
              return (str_replace($uri, $entity . ":", $node->attributes->getNamedItem("type")->nodeValue));
            }
          }
        }

        return ($node->attributes->getNamedItem("type")->nodeValue);
      }
    }

    return "";
  }

  function getContent(&$node)
  {
    if($node != null && (get_class($node) == "DOMNode" ||
                         get_class($node) == "DOMElement")) 
    {    
      if(isset($node->attributes))
      {    
        return($node->nodeValue);
      }
    }
    
    return("");
  }
  
  function removeChildren(&$node) 
  {
    while ($node->firstChild) 
    {
      while ($node->firstChild->firstChild) 
      {
        $this->removeChildren($node->firstChild);
      }
      
      $node->removeChild($node->firstChild);
    }
  }  
  
  function removePredicatesByType(&$subject, $type)
  {
    $type = $this->transformPrefix($type);

    $xpath = new DOMXPath($this->dom);

    $query = './/predicate[attribute::type="' . $type . '"]';

    $predicates = $xpath->query($query, $subject);
    
    foreach($predicates as $predicate)
    {
      $predicate->parentNode->removeChild($predicate);
    }
  }  
  
  function xmlEncode($string)
  { 
    // Replace all the possible entities by their character. That way, we won't "double encode" 
    // these entities. Otherwise, we can endup with things such as "&amp;amp;" which some
    // XML parsers doesn't seem to like (and throws errors).
    $string = str_replace(array ("%5C", "&amp;", "&lt;", "&gt;"), array ("\\", "&", "<", ">"), $string);
    
    return str_replace(array ("\\", "&", "<", ">"), array ("%5C", "&amp;", "&lt;", "&gt;"), $string); 
  } 
  
  function saveRdfN3()
  {
    $rdf_part = "@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>\n\n";
    $rdf_reification = "";
    
    $subjects = $this->getSubjects();

    foreach($subjects as $subject)
    {
      $subjectURI = $this->getURI($subject);
      $subjectType = $this->getType($subject, FALSE);

      $rdf_part .= "<$subjectURI> a <$subjectType> ;\n";

      $predicates = $this->getPredicates($subject);

      foreach($predicates as $predicate)
      {
        $objects = $this->getObjects($predicate);

        foreach($objects as $object)
        {
          $objectType = $this->getType($object);
          $predicateType = $this->getType($predicate, FALSE);

          if($objectType == "rdfs:Literal")
          {
            $objectValue = $this->getContent($object);
            $rdf_part .= "        <$predicateType> \"" . $this->escapeN3($objectValue) . "\" ;\n";
          }
          else
          {
            $objectURI = $this->getURI($object);
            $rdf_part .= "        <$predicateType> <$objectURI> ;\n";
          }
          
          
          // Check for reified statements.
          $reifies = $this->getReificationStatements($object);

          foreach($reifies as $reify)
          {
            $reifyPredicate = $this->getType($reify, FALSE);

            $rdf_reification .= "_:" . md5($this->getURI($subject) . $predicateType . $this->getURI($object))
              . " a rdf:Statement ;\n";
            $rdf_reification .= "    rdf:subject <" . $this->getURI($subject) . "> ;\n";
            $rdf_reification .= "    rdf:predicate <" . $predicateType . "> ;\n";
            $rdf_reification .= "    rdf:object <" . $this->getURI($object) . "> ;\n";
            $rdf_reification .= "    <$reifyPredicate> \"" . $this->escapeN3($this->getValue($reify)) . "\" .\n\n";
          }          
        }
      }

      if(strlen($rdf_part) > 0)
      {
        $rdf_part = substr($rdf_part, 0, strlen($rdf_part) - 2) . ". \n";
      }
    }
    
    return($rdf_part.$rdf_reification);    
  } 
  
  private function escapeN3($literal)
  {
    $literal = str_replace("\\","\\\\", $literal);

    return str_replace(array('"', "'"), array('\\"', "\\'"), $literal);
  }
}


?>