source: php/trunk/classes/Core.php

<?php

/* RDFInt.php - RDF Interfaces for PHP
 * Copyright 2011 netlabs.org
 * Author: Christian Langanke, Adrian Gschwend
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

namespace rdfint_core;


class Core {

  private $usedLibrary = NULL;
  private $aNamespace;

  // ---------------------------------------

  public function __construct() {

    // determ ine library to use
    $this->usedLibrary = 'arc';
    
    $this->aNamespace = array();

  } // public function __construct

  // ---------------------------------------

  public function parse( $uri) {

    $newTriples = array();

    switch ($this->usedLibrary) {

      case 'arc':
        $arcParser = \ARC2::getRDFParser();
        $arcParser->parse( $uri);
        $newTriples = $arcParser->getTriples();
        break;

    }
    return $newTriples;
  }

  // ---------------------------------------

  public function serialize( $aTriples, $type) {

    $data = Null;

    switch ($this->usedLibrary) {

      case 'arc':
        // set the supported types and shortcut them to the ones we use in there
        $validTypes = array( 'application/rdf+xml' => 'rdfxml' ,
                             'application/rdfxml' => 'rdfxml',
                             'text/turtle' => 'turtle',
                             'application/x-turtle' => 'turtle',
                             'text/n3' => 'n3',
                             'application/json' => 'json');
    
        // check if explicit mime type is specified
        if (isset( $validTypes[ $type])) {
          $type = $validTypes[ $type];
        }  else {
          // check if internal type is given
          $internalTypes = array_unique( array_flip( $validTypes));
          if (!isset( $internalTypes[ $type])) {
            $data = false;
            break;
          }
        }

        switch ($type) {

          case 'rdfxml':  $ser = \ARC2::getRDFXMLSerializer();   break;
          case 'turtle':  $ser = \ARC2::getTurtleSerializer();   break;
          case 'n3':      $ser = \ARC2::getNTriplesSerializer(); break;
          case 'json':    $ser = \ARC2::getRDFJSONSerializer();  break;

        } // switch ($type)

        $data = $ser->getSerializedTriples( $aTriples);

        break;
    }
    return $data;
  }

  // ---------------------------------------

  public function runQuery( $config, $statement) {

    $result = Null;

    switch ($this->usedLibrary) {

      case 'arc':

        $store = \ARC2::getRemoteStore( $config);
        $index = $store->query( $statement, 'raw');

        if ((is_array( $index) && (is_array( $index[ "errors"]))))
          $result = false;
        else
          $result = \ARC2::getTriplesFromIndex( $index);
        break;

    }
    return $result;

  }

  // ---------------------------------------

  public function filterTriples( $aTriples,
                                 $subject = NULL,
                                 $predicate = NULL,
                                 $object = NULL) {

    $searchTriple = array ( 's' =>  $subject, 'p' =>  $predicate, 'o' =>  $object);

    // resolve namespace prefixes
    $uriSubject   = $this->resolve( $subject);
    $uriPredicate = $this->resolve( $predicate);
    $uriObject    = $this->resolve( $object);

    // resolve method may return NULL, then use original value
    $uriSubject   = ($uriSubject   === NULL) ? $subject   : $uriSubject;
    $uriPredicate = ($uriPredicate === NULL) ? $predicate : $uriPredicate;
    $uriObject    = ($uriObject    === NULL) ? $object    : $uriObject;

    // filter all available triples
    $aresult = array();
    foreach ($aTriples as $aTriple) {

      // must be triple
      if ((isset( $aTriple[ 'type'])) &&
          ($aTriple[ 'type'] != 'triple'))
        continue;

      // check subject and predicate match if given
      if (($uriSubject != NULL)   && (strcmp( $uriSubject, $aTriple[ 's'])))
        continue;

      if (($uriPredicate != NULL) && (strcmp( $uriPredicate, $aTriple[ 'p'])))
        continue;

      // check object if given
      if ($uriObject != NULL) {

        // check object match
        if (strcmp( $uriObject, $aTriple[ 'o']))
          continue;

      } //  if ($uriObject != NULL) {

      // store in result array
      $aresult[] = $aTriple;

    } // foreach ($aTriples as $aTriple)

    return $aresult;

  } //  static function filterTriples
  
  // ---------------------------------------
  
  public function setMapping( $prefix, $uriNamespace) {

    if ($prefix == '')
      return false;

    // add colon to prefix as internally req.
    if (substr( $prefix, -1) != ':')
      $prefix = "$prefix:";

    if (isset( $this->aNamespace[ $prefix])) {
      $oldUriNamespace = $this->aNamespace[ $prefix];
      if ($oldUriNamespace == $uriNamespace)
        $debugmessage = "Namespace mapping exists: @prefix $prefix <$uriNamespace> .";
      else
        $debugmessage = "Namespace mapping overwritten: @prefix $prefix <$uriNamespace> .\n" .
                        "Old mapping was: @prefix $prefix <$oldUriNamespace>";
    } else {
      $debugmessage = "Namespace mapping added: @prefix $prefix <$uriNamespace> .";
    }

    // set URI
    $this->aNamespace[ $prefix] = $uriNamespace;
    return $debugmessage;

  } // public function setMapping
  
  // ---------------------------------------

  public function resolve( $curie) {

    $replacecount = 1;
    $uri = NULL;
    if ($curie != NULL) {
      if ($this->aNamespace != NULL) {
        if ((strpos( $uri, ":/") !== false) ||
            (strpos( $uri, "_:") === 0)) {
          $uri = $curi;
        } else {
          // check for namespaces
          foreach ($this->aNamespace as $prefix => $uriNamespace) {
            // check for prefix match
            $posPrefix = strpos( $curie, $prefix);
            if ($posPrefix === 0) {
              // replace prefix and bail out
              $uri = str_replace( $prefix, $uriNamespace, $curie, $replacecount);
              break;
            }
          } // foreach ($this->aNamespace
        } // if ((strpos ...
      } // if ($aNamespace != NULL) {
    }  // if ($uri != NULL) {

    return $uri;

  } //  public function resolve

  // ---------------------------------------

  public function shrink( $uri) {

    $replacecount = 1;
    if ($uri != NULL) {
      if ($this->aNamespace != NULL) {
        if (strpos( $uri, ":/") !== false) {
          foreach ($this->aNamespace as $prefix => $uriNamespace) {
            // search namespace URI
            $posNamespace = strpos( $uri, $uriNamespace);
            if ($posNamespace === false)
              continue;
            // replace namespace URI and bail out
            $uri = str_replace( $uriNamespace, $prefix, $uri, &$replacecount);
            break;
          } // foreach ($aNamespace
        } // if (strpos( $uri, ":/") !== false)
      } // if ($aNamespace != NULL) {
    }  // if ($uri != NULL) {

    return $uri;

  }  //  public function shrink


} // class Core

?>