Source for file ResModel.php

Documentation is available at ResModel.php

  1. <?php
  2. // ----------------------------------------------------------------------------------
  3. // Class: ResModel
  4. // ----------------------------------------------------------------------------------
  5.  
  6. /**
  7. * A ResModel provides an resource centric view on an underlying RDF model.
  8. * ResModels show information not as statements but as resources with
  9. * properties, similar to Jena models. ResModels may create Resources [URI
  10. * nodes and bnodes]. Creating a Resource does not make the Resource visible to
  11. * the model; Resources are only "in" Models if Statements about them are added
  12. * to the Model. Similarly the only way to "remove" a Resource from a Model is
  13. * to remove all the Statements that mention it.
  14. * 
  15. * When a Resource or Literal is created by a Model, the Model is free to re-use an existing
  16. * Resource or Literal object with the correct values, or it may create a fresh one.
  17. *
  18. * @version  $Id: fsource_resModel__resModelResModel.php.html 443 2007-06-01 16:25:38Z cax $
  19. * @author Daniel Westphal <mail at d-westphal dot de>
  20. *
  21. *
  22. * @package     resModel
  23. * @access    public
  24. ***/
  25.  
  26. class ResModel
  27. {
  28.     
  29.     /**
  30.     * Holds a reference to the assoiated memmodel/dbmodel/infmodel
  31.     * @var        ResResource 
  32.     * @access    private
  33.     */
  34.     var $model;
  35.  
  36.     
  37.     /**
  38.     * Constructor
  39.     * You have to supply a memmodel/dbmodel/infmodel to save the statements.
  40.     *
  41.     * @param object model $model 
  42.     * @access    public
  43.     */    
  44.     function ResModel(& $model)
  45.     {
  46.         if (!is_a($model,'Model'))
  47.             trigger_error(RDFAPI_ERROR . '(class: ResourceLayer; method: ResourceLayer): 
  48.                 $model has to be object of class Model', E_USER_ERROR);    
  49.         
  50.         $this->model =& $model;            
  51.     }
  52.     
  53.     /**
  54.     * Create a new resource associated with this model.
  55.     * If the uri string isn't set, this creates a bnode.
  56.     * Otherwise it creates a URI node.
  57.     * A URI resource is .equals() to any other URI Resource with the same URI
  58.     * (even in a different model - be warned).
  59.     * 
  60.     * This method may return an existing Resource with the correct URI and model,
  61.     * or it may construct a fresh one, as it sees fit.
  62.     *
  63.     * Operations on the result Resource may change this model.
  64.     *
  65.        * @param    string    $uri 
  66.        * @return    object ResResource 
  67.        * @access    public
  68.        */
  69.     function createResource($uri = null)
  70.     {
  71.         $resResource = new ResResource($uri);
  72.         //associate the resource with this model, and get a unique identifier
  73.         //if it is bnode.
  74.         $resResource->setAssociatedModel($this);
  75.         
  76.         return $resResource;
  77.     } 
  78.     
  79.     /**
  80.     * Create a new Property associated with this model.
  81.     * This method may return an existing property with the correct URI and model,
  82.     * or it may construct a fresh one, as it sees fit.
  83.     *
  84.     * Subsequent operations on the returned property may modify this model.
  85.     *  
  86.     *
  87.        * @param    string    $uri 
  88.        * @return    object ResProperty 
  89.        * @access    public
  90.        */
  91.     function createProperty($uri = null)
  92.     {
  93.         $resProperty = new ResProperty($uri);
  94.         $resProperty->setAssociatedModel($this);
  95.             
  96.         return $resProperty;
  97.     }
  98.     
  99.     /**
  100.     * Create an untyped literal from a String value with a specified language.
  101.     *
  102.     * If you want to type this literal, you have to set a datatype before
  103.     * adding it to the model.
  104.     *  
  105.     *
  106.        * @param    string    $label 
  107.        * @param    string    $languageTag 
  108.        * @return    object ResLiteral 
  109.        * @access    public
  110.        */    
  111.     function createLiteral($label,$languageTag = null)
  112.     {
  113.         $resLiteral = new ResLiteral($label,$languageTag);
  114.         $resLiteral->setAssociatedModel($this);
  115.         
  116.         return $resLiteral;
  117.     }
  118.     
  119.     /**
  120.     * General method to search for triples.
  121.     * NULL input for any parameter will match anything.
  122.     * Example:  $result = $m->find( NULL, NULL, $node );
  123.     * Finds all Statements with $node as object.
  124.     * Returns an array of statements with ResResources.
  125.     *
  126.     * @param    object ResResource    $subject 
  127.     * @param    object ResResource    $predicate 
  128.     * @param    object ResResource    $object 
  129.     * @return    array 
  130.     * @access    public
  131.     * @throws    PhpError
  132.     */
  133.     function find($subject,$predicate, $object)
  134.     {
  135.         $result=array();
  136.         //convert ResResources to Resources and Blanknodes
  137.         $resmodel=$this->model->find(    $this->_resNode2Node($subject),
  138.                                         $this->_resNode2Node($predicate),
  139.                                         $this->_resNode2Node($object)
  140.                                      );
  141.         //convert Resources, Blanknodes to ResResources                             
  142.         foreach ($resmodel->triples as $statement) 
  143.         {
  144.             $result[]=new Statement($this->_node2ResNode($statement->getSubject()),
  145.                                     $this->_node2ResNode($statement->getPredicate(),true),
  146.                                     $this->_node2ResNode($statement->getObject())
  147.                                     );
  148.         };
  149.         return $result;
  150.         
  151.     }
  152.     
  153.     /**
  154.     * Searches for triples and returns the first matching statement.
  155.     * NULL input for any parameter will match anything.
  156.     * Example:  $result = $m->findFirstMatchingStatement( NULL, NULL, $node );
  157.     * Returns the first statement with ResResources of the Model where the object equals $node.
  158.     * Returns an NULL if nothing is found.
  159.     * You can define an offset to search.
  160.     *
  161.     * @param    object Node    $subject 
  162.     * @param    object Node    $predicate 
  163.     * @param    object Node    $object 
  164.     * @param    integer $offset 
  165.     * @return    object Statement 
  166.     * @access    public
  167.     */
  168.     function findFirstMatchingStatement($subject,$predicate,$object,$offset = 0)
  169.     {
  170.     
  171.         $statement = $this->model->findFirstMatchingStatement(    $this->_resNode2Node($subject),
  172.                                                                 $this->_resNode2Node($predicate),
  173.                                                                 $this->_resNode2Node($object),
  174.                                                                 $offset
  175.                                                               );
  176.         if ($statement!==null)
  177.         {                                            
  178.             return new Statement(    $this->_node2ResNode($statement->getSubject()),
  179.                                     $this->_node2ResNode($statement->getPredicate(),true),
  180.                                     $this->_node2ResNode($statement->getObject())
  181.                                 );
  182.         } else 
  183.         {
  184.             return null;
  185.         }
  186.     }
  187.     
  188.     /**
  189.     * Adds a new triple to the Model without checking if the statement is already in the Model.
  190.     * So if you want a duplicate free Model use the addWithoutDuplicates() function (which is slower then add())
  191.     * Expects a statements with ResResources(ResLiterals)
  192.     *
  193.     * @param    object Statement    $statement 
  194.     * @access    public
  195.     * @throws    PhpError
  196.     */
  197.     function add($statement)
  198.     {
  199.         return $this->model->add(new Statement(    $this->_resNode2Node($statement->getSubject()),
  200.                                                 $this->_resNode2Node($statement->getPredicate()),
  201.                                                 $this->_resNode2Node($statement->getObject()))
  202.                                                );        
  203.     }
  204.     /**
  205.     * Checks if a new statement is already in the Model and adds the statement, if it is not in the Model.
  206.     * addWithoutDuplicates() is significantly slower then add().
  207.     * Retruns TRUE if the statement is added.
  208.     * FALSE otherwise.
  209.     * Expects a statements with ResResources(ResLiterals)
  210.     *
  211.     * @param    object Statement    $statement 
  212.     * @return   boolean 
  213.     * @access    public
  214.     * @throws    PhpError
  215.     */
  216.     function addWithoutDuplicates($statement)
  217.     {
  218.         return $this->model->addWithoutDuplicates(new Statement($this->_resNode2Node($statement->getSubject()),
  219.                                                                 $this->_resNode2Node($statement->getPredicate()),
  220.                                                                 $this->_resNode2Node($statement->getObject()))
  221.                                                                 );    
  222.     }
  223.     
  224.     /**
  225.     * Tests if the Model contains the given statement.
  226.     * TRUE if the statement belongs to the model;
  227.     * FALSE otherwise.
  228.     * Expects a statement of ResResources(ResLiterals)
  229.     *
  230.     * @param    object Statement    $statement 
  231.     * @return    boolean 
  232.     * @access    public
  233.     */
  234.     function contains(& $statement)
  235.     {
  236.         
  237.         return $this->model->contains(new Statement($this->_resNode2Node($statement->getSubject()),
  238.                                                     $this->_resNode2Node($statement->getPredicate()),
  239.                                                     $this->_resNode2Node($statement->getObject()))
  240.                                                     );
  241.     }
  242.     
  243.     /**
  244.     * Determine if all of the statements in a model are also contained in this model.
  245.     * True if all of the statements in $model are also contained in this model and false otherwise.
  246.     *
  247.     * @param    object Model    &$model 
  248.     * @return    boolean 
  249.     * @access    public
  250.     */
  251.     function containsAll(& $model)
  252.     {
  253.         if (is_a($model,'ResModel'))
  254.             return $this->model->containsAll($model->getModel());
  255.         
  256.         return $this->model->containsAll($model);
  257.     }
  258.     
  259.     /**
  260.     * Determine if any of the statements in a model are also contained in this model.
  261.     * True if any of the statements in $model are also contained in this model and false otherwise.
  262.     *
  263.     * @param    object Model    &$model 
  264.     * @return    boolean 
  265.     * @access    public
  266.     */    
  267.     function containsAny(& $model)
  268.     {
  269.         if (is_a($model,'ResModel'))
  270.             return $this->model->containsAny($model->getModel());
  271.         return $this->model->containsAny($model);
  272.     }
  273.     
  274.     /**
  275.     * Determine if the node (ResResource / ResLiteral) $node appears in any statement of this model.
  276.     *
  277.     * @param    object Node    &$node 
  278.     * @return    boolean 
  279.     * @access    public
  280.     */    
  281.     function containsResource(& $node)
  282.     {
  283.         if ($this->findFirstMatchingStatement($node,null,null) === null)
  284.             if ($this->findFirstMatchingStatement(null,$node,null) === null)
  285.                 if ($this->findFirstMatchingStatement(null,null,$node) === null)
  286.                     return false;
  287.                     
  288.         return true;
  289.     }
  290.     
  291.     /**
  292.     * Create a literal from a String value with the $dtype Datatype
  293.     * An existing literal of the right value may be returned, or a fresh one created.
  294.     *
  295.     * @param    string    $value 
  296.     * @param    string     $dtype 
  297.     * @return     object ResLiteral 
  298.     * @access    public
  299.     */
  300.     function createTypedLiteral($value,$dtype)
  301.     {
  302.         $resLiteral = new ResLiteral($value);
  303.         $resLiteral->setDatatype($dtype);
  304.         $resLiteral->setAssociatedModel($this);
  305.         
  306.         return $resLiteral;
  307.     }
  308.     
  309.     /**
  310.     * Checks if two models are equal.
  311.     * Two models are equal if and only if the two RDF graphs they represent are isomorphic.
  312.     * 
  313.     * Warning: This method doesn't work correct with models where the same blank node has different
  314.     * identifiers in the two models. We will correct this in a future version.
  315.     *
  316.     * @access    public
  317.     * @param    object    model &$that 
  318.     * @throws    phpErrpr
  319.     * @return    boolean 
  320.     */        
  321.     function equals(& $that)
  322.     {
  323.         if (is_a($that,'ResModel'))
  324.             return $this->model->equals($that->getModel());
  325.         return $this->model->equals($that);    
  326.     }
  327.     
  328.     /** 
  329.     * Returns a new model that is the subtraction of another model from this model.
  330.     *
  331.     * @param    object Model $model 
  332.     * @return    object MemModel 
  333.     * @access    public
  334.     * @throws phpErrpr
  335.     */ 
  336.     function subtract($model)
  337.     {
  338.         if (is_a($model,'ResModel'))
  339.             return $this->model->subtract($model->getModel());
  340.         return $this->model->subtract($model);
  341.     }
  342.     
  343.     /** 
  344.     * Answer a statement find(s, p, null) with ResResources(ResLiterals) from this model.
  345.     * If none exist, return null; if several exist, pick one arbitrarily.
  346.     *
  347.     * @param    object ResResource $subject 
  348.     * @param    object ResResource $property 
  349.     * @return    object Statement 
  350.     * @access    public
  351.     * @throws phpErrpr
  352.     */ 
  353.     function getProperty($subject,$property)
  354.     {
  355.     
  356.         $statement= $this->model->findFirstMatchingStatement(    $this->_resNode2Node($subject),
  357.                                                                 $this->_resNode2Node($property),
  358.                                                                 null
  359.                                                             );
  360.         if ($statement === null)
  361.             return null;
  362.                                                                 
  363.         return new Statement($this->_node2ResNode($statement->getSubject()),
  364.                                     $this->_node2ResNode($statement->getPredicate(),true),
  365.                                     $this->_node2ResNode($statement->getObject())
  366.                             );
  367.                                                     
  368.     }
  369.     
  370.     /**
  371.     * Checks if MemModel is empty
  372.     *
  373.     * @return    boolean 
  374.     * @access    public
  375.     */
  376.     function isEmpty()
  377.     {
  378.         return $this->model->isEmpty();
  379.     }
  380.     
  381.     /** 
  382.     * Returns a ResIterator with all objects in a model.
  383.     *
  384.     * @return    object ResIterator 
  385.     * @access    public
  386.     * @throws phpErrpr
  387.     */
  388.     function listObjects()
  389.     {
  390.         return $this->listObjectsOfProperty(null);
  391.     }
  392.     
  393.     /** 
  394.     * Returns a ResIterator with all objects with a given property and property value.
  395.     *
  396.     * @param    object ResResource    $property 
  397.     * @param    object ResResource    $value 
  398.     * @return    object ResIterator 
  399.     * @access    public
  400.     */
  401.     function listObjectsOfProperty($property, $value = null)
  402.     {
  403.         return new ResIterator(null,$property,$value,'o',$this);
  404.     }
  405.  
  406.     
  407.     /** 
  408.     * Returns a ResIterator with all subjects in a model.
  409.     *
  410.     * @return    object ResIterator 
  411.     * @access    public
  412.     * @throws phpErrpr
  413.     */
  414.     function listSubjects()
  415.     {
  416.         return $this->listSubjectsWithProperty(null);
  417.     }
  418.     
  419.     /** 
  420.     * Returns a ResIterator with all subjects with a given property and property value.
  421.     *
  422.     * @param    object ResResource    $property 
  423.     * @param    object ResResource    $value 
  424.     * @return    object ResIterator 
  425.     * @access    public
  426.     * @throws phpErrpr
  427.     */
  428.     function listSubjectsWithProperty($property,$value = null)
  429.     {
  430.         return new ResIterator(null,$property,$value,'s',$this);
  431.     }
  432.     
  433.     /**
  434.     * Removes the statement of ResResources(ResTriples) from the MemModel.
  435.     * TRUE if the statement is removed.
  436.     * FALSE otherwise.
  437.     *
  438.     * @param    object Statement    $statement 
  439.     * @return   boolean 
  440.     * @access    public
  441.     * @throws    PhpError
  442.     */    
  443.     function remove($statement)
  444.     {
  445.         return $this->model->remove(new Statement(    $this->_resNode2Node($statement->getSubject()),
  446.                                                     $this->_resNode2Node($statement->getPredicate()),
  447.                                                     $this->_resNode2Node($statement->getObject())
  448.                                                   ));
  449.     }
  450.     
  451.     /**
  452.     * Number of statements in the MemModel
  453.     *
  454.     * @return    integer 
  455.     * @access    public
  456.     */
  457.     function size()
  458.     {
  459.         return $this->model->size();
  460.     }
  461.     
  462.     /** 
  463.     * Returns a new Model that is the set-union of the model with another model.
  464.     * Duplicate statements are removed. If you want to allow duplicates, use addModel() which is much faster.
  465.     *
  466.     * The result of taking the set-union of two or more RDF graphs (i.e. sets of triples)
  467.     * is another graph, which we will call the merge of the graphs.
  468.     * Each of the original graphs is a subgraph of the merged graph. Notice that when forming
  469.     * a merged graph, two occurrences of a given uriref or literal as nodes in two different
  470.     * graphs become a single node in the union graph (since by definition they are the same
  471.     * uriref or literal) but blank nodes are not 'merged' in this way; and arcs are of course
  472.     * never merged. In particular, this means that every blank node in a merged graph can be
  473.     * identified as coming from one particular graph in the original set of graphs.
  474.     * 
  475.     * Notice that one does not, in general, obtain the merge of a set of graphs by concatenating
  476.     * their corresponding N-triples documents and constructing the graph described by the merged
  477.     * document, since if some of the documents use the same node identifiers, the merged document
  478.     * will describe a graph in which some of the blank nodes have been 'accidentally' merged.
  479.     * To merge Ntriples documents it is necessary to check if the same nodeID is used in two or
  480.     * more documents, and to replace it with a distinct nodeID in each of them, before merging the
  481.     * documents. (Not implemented yet !!!!!!!!!!!)
  482.     *
  483.     * @param    object Model    $model 
  484.     * @return    object MemModel 
  485.     * @access    public
  486.     * @throws phpErrpr
  487.     *
  488.     */
  489.     function & unite(& $model)
  490.     {
  491.         if (is_a($model,'ResModel'))
  492.             return $this->model->unite($model->getModel());
  493.         return $this->model->unite($model);
  494.     }
  495.     
  496.     /** 
  497.     * Adds another model to this MemModel.
  498.     * Duplicate statements are not removed.
  499.     * If you don't want duplicates, use unite().
  500.     * If any statement of the model to be added to this model contains a blankNode
  501.     * with an identifier already existing in this model, a new blankNode is generated.
  502.     *
  503.     * @param    object Model    $model 
  504.     * @access    public
  505.     * @throws phpErrpr
  506.     *
  507.     */
  508.     function addModel(&$model)  
  509.     {
  510.         if (is_a($model,'ResModel'))
  511.             return $this->model->addModel($model->getModel());
  512.         return $this->model->addModel($model);
  513.     }
  514.     
  515.     /**
  516.     * Create a new RDF Container from type rdf:Alt
  517.     * This method may return an existing container with the correct URI and model,
  518.     * or it may construct a fresh one, as it sees fit.
  519.     *
  520.     * Subsequent operations on the returned Container may modify this model.
  521.     *  
  522.     *
  523.        * @param    string    $uri 
  524.        * @return    object ResProperty 
  525.        * @access    public
  526.        */
  527.     function createAlt($uri = null)
  528.     {
  529.         $resAlt = new ResAlt($uri);
  530.         $resAlt->setAssociatedModel($this);
  531.             
  532.         return $resAlt;        
  533.     }
  534.     
  535.     /**
  536.     * Create a new RDF Container from type rdf:Bag
  537.     * This method may return an existing container with the correct URI and model,
  538.     * or it may construct a fresh one, as it sees fit.
  539.     *
  540.     * Subsequent operations on the returned Container may modify this model.
  541.     *  
  542.     *
  543.        * @param    string    $uri 
  544.        * @return    object ResProperty 
  545.        * @access    public
  546.        */
  547.     function createBag($uri = null)
  548.     {
  549.         $resBag = new ResBag($uri);
  550.         $resBag->setAssociatedModel($this);
  551.             
  552.         return $resBag;
  553.     }
  554.     
  555.     /**
  556.     * Create a new RDF Container from type rdf:Seq
  557.     * This method may return an existing container with the correct URI and model,
  558.     * or it may construct a fresh one, as it sees fit.
  559.     *
  560.     * Subsequent operations on the returned Container may modify this model.
  561.     *  
  562.     *
  563.        * @param    string    $uri 
  564.        * @return    object ResProperty 
  565.        * @access    public
  566.        */
  567.     function createSeq($uri = null)
  568.     {
  569.         $resSeq = new ResSeq($uri);
  570.         $resSeq->setAssociatedModel($this);
  571.             
  572.         return $resSeq;
  573.     }    
  574.     
  575.     /**
  576.     * Create a new RDF Collection from type rdf:List
  577.     * This method may return an existing container with the correct URI and model,
  578.     * or it may construct a fresh one, as it sees fit.
  579.     *
  580.     * Subsequent operations on the returned Container may modify this model.
  581.     *  
  582.     *
  583.        * @param    string    $uri 
  584.        * @return    object ResProperty 
  585.        * @access    public
  586.        */
  587.     function createList($uri = null)
  588.     {
  589.         $resList = new ResList($uri);
  590.         $resList->setAssociatedModel($this);
  591.             
  592.         return $resList;    
  593.     }
  594.     
  595.     /**
  596.     * Returns a reference to the underlying model (Mem/DB/InfModel) that contains the statements
  597.     *  
  598.     *
  599.        * @return    object Model 
  600.        * @access    public
  601.        */    
  602.     function & getModel()
  603.     {
  604.         return  $this->model;
  605.     }
  606.     
  607.     
  608.     /**
  609.     * Internal method, that returns a resource URI that is unique for the Model.
  610.     * URIs are generated using the base_uri of the Model, the prefix and a unique number.
  611.     * If no prefix is defined, the bNode prefix, defined in constants.php, is used.
  612.     *
  613.     * @param    string    $prefix 
  614.     * @return    string 
  615.     * @access    private
  616.     */
  617.     function getUniqueResourceURI($bnodePrefix)
  618.     {
  619.         return $this->model->getUniqueResourceURI($bnodePrefix);
  620.     }
  621.     
  622.     /**
  623.     * Load a model from a file containing RDF, N3 or N-Triples.
  624.     * This function recognizes the suffix of the filename (.n3 or .rdf) and
  625.     * calls a suitable parser, if no $type is given as string ("rdf" "n3" "nt");
  626.     * If the model is not empty, the contents of the file is added to this DbModel.
  627.     *
  628.     * @param     string     $filename 
  629.     * @param     string     $type 
  630.     * @param   boolean $stream 
  631.     * @access    public
  632.     */
  633.     function load($filename, $type = NULL, $stream=false)
  634.     {
  635.         $this->model->load($filename, $type = NULL, $stream=false);
  636.     }
  637.     
  638.     /**
  639.     * Return current baseURI.
  640.     *
  641.     * @return  string 
  642.     * @access    public
  643.     */
  644.     function getBaseURI()  
  645.     {
  646.         return $this->model->getBaseURI();
  647.     }
  648.  
  649.     /**
  650.     * Saves the RDF,N3 or N-Triple serialization of the MemModel to a file.
  651.     * You can decide to which format the model should be serialized by using a
  652.     * corresponding suffix-string as $type parameter. If no $type parameter
  653.     * is placed this method will serialize the model to XML/RDF format.
  654.     * Returns FALSE if the MemModel couldn't be saved to the file.
  655.     *
  656.     * @access    public
  657.     * @param     string     $filename 
  658.     * @param     string     $type 
  659.     * @throws   PhpError
  660.     * @return    boolean 
  661.     */  
  662.     function saveAs($filename, $type ='rdf') 
  663.     {
  664.         return $this->model->saveAs($filename, $type ='rdf');
  665.     }
  666.     
  667.     /**
  668.     * Writes the RDF serialization of the MemModel as HTML table.
  669.     *
  670.     * @access    public
  671.     */  
  672.     function writeAsHTMLTable()
  673.     {
  674.         $this->model->writeAsHtmlTable();
  675.     }
  676.     
  677.     /** 
  678.     * Returns a new model containing all the statements which are in both this model and another.
  679.     *
  680.     * @param    object Model    $model 
  681.     * @return    object MemModel 
  682.     * @access    public
  683.     * @throws phpErrpr
  684.     */ 
  685.     function & intersect(& $model)
  686.     {
  687.         if (is_a($model,'ResModel'))
  688.             return $this->model->intersect($model->getModel());
  689.         return $this->model->intersect($model);
  690.     }
  691.     
  692.     /** 
  693.     * converts a Resource,Blanknode,Literal into a ResResource, ResProperty, or ResLiteral
  694.     *
  695.     * @param    object Node    $node 
  696.     * @param    boolean        $isProperty 
  697.     * @return    object ResResource / ResProperty / ResLiteral
  698.     * @access    private
  699.     * @throws phpErrpr
  700.     */ 
  701.     function _node2ResNode($node, $isProperty = false)
  702.     {
  703.         if (is_a($node,'Literal'))
  704.         {
  705.             $return= new ResLiteral($node->getLabel(),$node->getLanguage());
  706.             $return->setDatatype($node->getDatatype());
  707.             $return->setAssociatedModel($this);
  708.  
  709.             return $return;
  710.         }
  711.         if (is_a($node,'Resource'))
  712.         {
  713.             if ($isProperty)
  714.             {
  715.                 $res= new ResProperty($node->getLabel());
  716.             } else 
  717.             {
  718.                 $res= new ResResource($node->getLabel());
  719.             }
  720.             $res->setAssociatedModel($this);
  721.             if (is_a($node,'Blanknode'))
  722.                 $res->setIsAnon(true);    
  723.         
  724.             return $res;
  725.         }
  726.     }
  727.     
  728.     /** 
  729.     * converts a ResResource, ResProperty, or ResLiteral into a Resource, Blanknode, or Literal
  730.     *
  731.     * @param    object ResNode    $resNode 
  732.     * @return    object Node 
  733.     * @access    private
  734.     * @throws phpErrpr
  735.     */ 
  736.     function _resNode2Node($resNode)
  737.     {
  738.         if (is_a($resNode,'ResResource'))
  739.         {
  740.             if ($resNode->getIsAnon())    
  741.             {
  742.                 $return=new BlankNode($resNode->getURI());
  743.             } else 
  744.             {
  745.                 $return=new Resource($resNode->getURI());    
  746.             }    
  747.         return $return;    
  748.         }
  749.         
  750.         if (is_a($resNode,'ResLiteral'))
  751.         {
  752.             $literal=new Literal($resNode->getLabel(),$resNode->getLanguage());
  753.             if ($resNode->getDatatype() != null)
  754.                 $literal->setDatatype($resNode->getDatatype());
  755.             return $literal;
  756.         }
  757.     }
  758.     
  759.     /**
  760.     * Set a base URI for the MemModel.
  761.     * Affects creating of new resources and serialization syntax.
  762.     * If the URI doesn't end with # : or /, then a # is added to the URI.
  763.     * @param    string    $uri 
  764.     * @access    public
  765.     */
  766.     function setBaseURI($uri) 
  767.     {
  768.         $this->model->setBaseURI($uri);
  769.     }
  770.     
  771.     /**
  772.     * Writes the RDF serialization of the MemModel as HTML table.
  773.     *
  774.     * @access    public
  775.     * @return    string 
  776.     */  
  777.     function writeRdfToString() 
  778.     {
  779.         return $this->model->writeRdfToString();    
  780.     }
  781.     
  782.     /**
  783.     * Perform an RDQL query on this MemModel.
  784.     * This method returns an associative array of variable bindings.
  785.     * The values of the query variables can either be RAP's objects (instances of Node)
  786.     * if $returnNodes set to TRUE, or their string serialization.
  787.     *
  788.     * @access    public
  789.     * @param string $queryString 
  790.     * @param boolean $returnNodes 
  791.     * @return  array   [][?VARNAME] = object Node  (if $returnNodes = TRUE)
  792.     *       OR  array   [][?VARNAME] = string
  793.     *
  794.     */
  795.     function & rdqlQuery($queryString, $returnNodes = TRUE) 
  796.     {
  797.         return $this->model->rdqlQuery($queryString, $returnNodes);
  798.     }
  799.     
  800.     /**
  801.     * Perform an RDQL query on this MemModel.
  802.     * This method returns an RdqlResultIterator of variable bindings.
  803.     * The values of the query variables can either be RAP's objects (instances of Node)
  804.     * if $returnNodes set to TRUE, or their string serialization.
  805.     *
  806.     * @access    public
  807.     * @param string $queryString 
  808.     * @param boolean $returnNodes 
  809.     * @return  object RdqlResultIterator = with values as object Node  (if $returnNodes = TRUE)
  810.     *       OR  object RdqlResultIterator = with values as strings if (if $returnNodes = FALSE)
  811.     *
  812.     */
  813.     function rdqlQueryAsIterator($queryString, $returnNodes = TRUE) 
  814.     {
  815.         return $this->model->rdqlQueryAsIterator($queryString, $returnNodes);
  816.     }
  817.     
  818.     
  819.     /**
  820.     * Returns the models namespaces.
  821.     *
  822.     * @author   Tobias Gauß <tobias.gauss@web.de>
  823.     * @access   public
  824.     * @return   Array 
  825.     */
  826.     function getParsedNamespaces(){
  827.         return $this->model->getParsedNamespaces();
  828.     }
  829.  
  830.  
  831.  
  832.     /**
  833.     * Adds the namespaces to the model. This method is called by
  834.     * the parser. !!!! addParsedNamespaces() not overwrites manual
  835.     * added namespaces in the model !!!!
  836.     *
  837.     * @author   Tobias Gauß <tobias.gauss@web.de>
  838.     * @access   public
  839.     * @param    Array $newNs 
  840.     */
  841.     function addParsedNamespaces($newNs){
  842.         $this->model->addParsedNamespaces($newNs);
  843.     }
  844.  
  845.  
  846.     /**
  847.     * Adds a namespace and prefix to the model.
  848.     *
  849.     * @author   Tobias Gauß <tobias.gauss@web.de>
  850.     * @access   public
  851.     * @param    String $prefix, String $nmsp
  852.     */
  853.     function addNamespace($prefix, $namespace){
  854.         $this->model->addNamespace($prefix, $namespace);
  855.     }
  856.     
  857.     /**
  858.     * removes a single namespace from the model
  859.     *
  860.     * @author   Tobias Gauß <tobias.gauss@web.de>
  861.     * @access   public
  862.     * @param    String $nmsp 
  863.     */
  864.     function removeNamespace($nmsp){
  865.         return $this->model->removeNamespace($nmsp);
  866.     }
  867.  
  868.     
  869.     
  870.     
  871.     
  872.     
  873. }

Documentation generated on Fri, 1 Jun 2007 16:51:35 +0200 by phpDocumentor 1.3.2