/** * Create a new URI object from a string. * * @param string $uri_string The string to use for the URI * @return void * @throws LibRDF_Error If unable to create a new URI * @access public */ public function __construct($uri_string) { $this->uri = librdf_new_uri(librdf_php_get_world(), $uri_string); if (!$this->uri) { throw new LibRDF_Error("Unable to create new URI from string"); } }
/** * Create a new parser. * * Name is the type of parser. Common parsers are "rdfxml", "ntriples" and * "turtle". If all arguments are NULL, any available parser for * application/rdf+xml will be used. * * @param string $name The name of the parser to use * @param string $mime_type The MIME type of the values to parse * @param string $type_uri The URI of the RDF syntax to parse * @return void * @throws LibRDF_Error If unable to create a new parser * @access public */ public function __construct($name = NULL, $mime_type = NULL, $type_uri = NULL) { if ($type_uri) { $type_uri = new LibRDF_URI($type_uri); } $this->parser = librdf_new_parser(librdf_php_get_world(), $name, $mime_type, $type_uri ? $type_uri->getURI() : $type_uri); if (!$this->parser) { throw new LibRDF_Error("Unable to create new parser"); } }
public function __construct() { if (!extension_loaded('redland')) { throw new \Exception('Redland php5-librdf is required for this parser'); } $format = 'turtle'; $this->world = librdf_php_get_world(); $this->parser = librdf_new_parser($this->world, $format, null, null); if (false === $this->parser) { throw new \Exception('Failed to create librdf_parser of type: ' . $format); } }
/** * Create a new query. * * Query language is any language supported by rasqal, including "rdql", * "sparql" and "triples". * * The syntax of the query is not checked until it is executed. * * @param string $query_string The contents of the query * @param string $base_uri The base URI to use * @param string $query_language The language of the query (default rdql) * @param string $query_uri The URI of the query language or NULL * @return void * @throws LibRDF_Error If unable to create a new query * @access public */ public function __construct($query_string, $base_uri = NULL, $query_language = "rdql", $query_uri = NULL) { if ($base_uri) { $base_uri = new LibRDF_URI($base_uri); } if ($query_uri) { $query_uri = new LibRDF_URI($query_uri); } $this->query = librdf_new_query(librdf_php_get_world(), $query_language, $query_uri ? $query_uri->getURI() : $query_uri, $query_string, $base_uri ? $base_uri->getURI() : $base_uri); if (!$this->query) { throw new LibRDF_Error("Unable to create a new query"); } }
public function newInstance($subject, $predicate, $object, $graph = null) { $world = librdf_php_get_world(); $factory = new NodeFactory(); try { $redlandSubject = $factory->createRedlandNodeFromNode($subject); $redlandPredicate = $factory->createRedlandNodeFromNode($predicate); $redlandObject = $factory->createRedlandNodeFromNode($object); $statement = librdf_new_statement_from_nodes($world, $redlandSubject, $redlandPredicate, $redlandObject); return new Statement($statement, $graph); } catch (\Exception $e) { $this->markTestSkipped('Can\'t execute this test because: ' . $e->getMessage()); } }
/** * @param string $uri URI of the new named node. * @return NamedNode */ public function createNamedNode($uri) { if ($uri === null) { throw new \Exception('Can\'t initialize node with null.'); } if (!NodeUtils::simpleCheckURI($uri)) { throw new \Exception('Invalid URI was given for RDF NamedNode creation.'); } // TODO catch invalid URIs $world = librdf_php_get_world(); $uri = librdf_new_uri($world, $uri); $redlandNode = librdf_new_node_from_uri($world, $uri); if ($redlandNode === null) { throw new \Exception('Initialization of redland node failed.'); } return new NamedNode($redlandNode); }
* the above three licenses. * * See LICENSE.html or LICENSE.txt at the top of this package for the * full license terms. * * */ /* ------------------------------------------------------------------------ */ print "Testing Redland...\n"; $dlls = array("redland.so", "php_redland.dll", "redland.dylib", "redland.bundle"); foreach ($dlls as $dll) { if (file_exists($dll)) { dl($dll); } } $world = librdf_php_get_world(); print "Redland world opened\n"; $storage = librdf_new_storage($world, 'hashes', 'dummy', "new=yes,hash-type='memory'"); print "Redland storage created\n"; $model = librdf_new_model($world, $storage, ''); print "Redland model created\n"; $parser = librdf_new_parser($world, 'rdfxml', 'application/rdf+xml', null); print "Redland parser created\n"; $uri = librdf_new_uri($world, 'file:../data/dc.rdf'); print "Parsing...\n"; librdf_parser_parse_into_model($parser, $uri, $uri, $model); print "Done...\n"; librdf_free_uri($uri); librdf_free_parser($parser); $query = librdf_new_query($world, 'sparql', null, "PREFIX dc: <http://purl.org/dc/elements/1.1/> SELECT ?a ?c ?d WHERE { ?a dc:title ?c . OPTIONAL { ?a dc:related ?d } }", null); print "Querying for dc:titles:\n";
/** * Constructor * * @return object EasyRdf_Parser_Redland */ public function __construct() { if (extension_loaded('redland')) { $this->_world = librdf_php_get_world(); if (!$this->_world) { throw new EasyRdf_Exception("Failed to initialise librdf world."); } } else { throw new EasyRdf_Exception("Redland PHP extension is not available."); } }
/** * Create a new LibRDF_Serializer. * * Name is the name of the serializer to use. Common choices are * "rdfxml", "ntriples" and "turtle". * * The "rdfxml" serializer is not pretty, outputing a flat list of * one XML element per statement. "rdfxml-abbrev" is a bit nicer, but * slower. * * @param string $name The name of the serializer to use * @param string $mime_type The MIME type of the syntax * @param string $type_uri The URI of the syntax * @return void * @throws LibRDF_Error If unable to create a new serializer * @access public */ public function __construct($name, $mime_type = NULL, $type_uri = NULL) { if ($type_uri) { $type_uri = new LibRDF_URI($type_uri); } $this->serializer = librdf_new_serializer(librdf_php_get_world(), $name, $mime_type, $type_uri ? $type_uri->getURI : $type_uri); if (!$this->serializer) { throw new LibRDF_Error("Unable to create new serializer"); } foreach (self::$namespaces as $uri => $prefix) { $this->setNamespace($uri, $prefix); } }
/** * Create a new Literal node. * * Both the $language and $datatype parameters are optional. * * The value of the literal node can either be a string or an XML literal * in the form of a DOMNodeList object. If using XML, a datatype of * http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral is implied, so * the datatype parameter cannot be used with XML. A literal cannot have * both a language and a datatype. * * @param mixed $value The literal value, either a string, a DOMNodeList or a librdf_node resource * @param string $datatype An optional datatype URI for the literal value * @param string $language An option language for the literal value * @return void * @throws LibRDF_Error If unabel to create a new node * @access public */ public function __construct() { $valuestr = ""; $is_xml = 0; // possible parameter lists are either LibRDF_Node $resource or // string $value, $datatype=NULL, string $language=NULL $num_args = func_num_args(); if ($num_args < 1 or $num_args > 3) { throw new LibRDF_Error("Invalid number of arguments"); } $value = func_get_arg(0); if ($num_args >= 2) { $datatype = func_get_arg(1); if ($datatype) { $datatype = new LibRDF_URI($datatype); } } else { $datatype = NULL; } if ($num_args >= 3) { $language = func_get_arg(2); } else { $language = NULL; } if ($num_args == 1 and is_resource($value)) { if (!librdf_node_is_literal($value)) { throw new LibRDF_Error("Argument 1 not a valid librdf_node " . " literal node"); } else { $this->node = $value; } } else { // value is XML, convert to a string and set the datatype if ($value instanceof DOMNodeList) { // XML values imply a datatype of // http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral, so // specifying a different datatype is an error if ($datatype !== NULL and $datatype->__toString() !== "http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral") { throw new LibRDF_Error("Cannot override datatype for XML literal"); } else { $datatype = NULL; } $valuestr = ""; foreach ($value as $item) { $valuestr .= $item->ownerDocument->saveXML($item); } $is_xml = 1; } else { $valuestr = (string) $value; $is_xml = 0; } if ($datatype !== NULL) { $datatype_uri = $datatype->getURI(); } else { $datatype_uri = NULL; } if ($is_xml or $datatype === NULL and $language === NULL) { $this->node = librdf_new_node_from_literal(librdf_php_get_world(), $valuestr, $language, $is_xml); } else { $this->node = librdf_new_node_from_typed_literal(librdf_php_get_world(), $valuestr, $language, $datatype_uri); } } if (!$this->node) { throw new LibRDF_Error("Unable to create new literal node"); } }
/** * Create a new Statement. * * The subject must be either a URINode or a BlankNode. The predicate * must be a URINode. * * @param mixed $statement The librdf_statement to copy or the source Node of a statement * @param LibRDF_Node $predicate The statement's predicate * @param LibRDF_Node $object The statement's object * @return void * @throws LibRDF_Error If unable to create a new statement * @access public */ public function __construct() { $num_args = func_num_args(); if ($num_args == 1) { $statement = func_get_arg(0); if (!is_resource($statement)) { throw new LibRDF_Error("Single parameter must be a librdf_statement"); } else { $this->statement = $statement; } } elseif ($num_args == 3) { $subject = func_get_arg(0); $predicate = func_get_arg(1); $object = func_get_arg(2); if ($subject instanceof LibRDF_Node and $predicate instanceof LibRDF_Node and $object instanceof LibRDF_Node) { $this->statement = librdf_new_statement_from_nodes(librdf_php_get_world(), librdf_new_node_from_node($subject->getNode()), librdf_new_node_from_node($predicate->getNode()), librdf_new_node_from_node($object->getNode())); } else { throw new LibRDF_Error("Arguments must be of type LibRDF_Node"); } } if (!$this->statement) { throw new LibRDF_Error("Uanble to create new statement"); } }
/** * Find a statement in the model. * * A NULL argument for any of source, predicate or target is treated as * a wildcard. If a context is given, only statements from that context * will be returned. The result is an object that be used in foreach * iteration. The returned iterator cannot be rewound. * * The search arguments can be either a (source, predicate target) triple * of LibRDF_Node objects or a LibRDF_Statement object. Valid argument * lists are (source, predicate, target, [context]) or * (statement, [context]). * * For more complex queries, see {@link LibRDF_Query}. * * @param mixed $statement The statement to match or a source node * @param LibRDF_Node $predicate The predicate to match * @param LibRDF_Node $target The target to match * @param LibRDF_URINode $context The context in which to search * @return LibRDF_StreamIterator An iterator over the matched statements * @access public */ public function findStatements() { $num_args = func_num_args(); if ($num_args == 1 or $num_args == 2) { $statement = func_get_arg(0); if (!$statement instanceof LibRDF_Statement) { throw new LibRDF_Error("First argument must be a LibRDF_Statement"); } if ($num_args == 2) { $context = func_get_arg(1); if (!$context instanceof LibRDF_URINode) { throw new LibRDF_Error("Context must be LibRDF_URINode"); } } else { $context = NULL; } $statement = $statement->getStatement(); } elseif ($num_args == 3 or $num_args == 4) { $source = func_get_arg(0); $predicate = func_get_arg(1); $target = func_get_arg(2); if ($source !== NULL) { if (!$source instanceof LibRDF_Node) { throw new LibRDF_Error("Argument 1 must be of type LibRDF_Node"); } else { $source = librdf_new_node_from_node($source->getNode()); } } if ($predicate !== NULL) { if (!$predicate instanceof LibRDF_Node) { throw new LibRDF_Error("Argument 2 must be of type LibRDF_Node"); } else { $predicate = librdf_new_node_from_node($predicate->getNode()); } } if ($target !== NULL) { if (!$target instanceof LibRDF_Node) { throw new LibRDF_Error("Argument 3 must be of type LibRDF_Node"); } else { $target = librdf_new_node_from_node($target->getNode()); } } if ($num_args == 4) { $context = func_get_arg(3); if (!$context instanceof LibRDF_URINode) { throw new LibRDF_Error("Context must be LibRDF_URINode"); } } else { $context = NULL; } $statement = librdf_new_statement_from_nodes(librdf_php_get_world(), $source, $predicate, $target); } else { throw new LibRDF_Error("findStatements takes 2-4 arguments"); } if ($context !== NULL) { $stream_resource = librdf_model_find_statements_in_context($this->model, $statement, $context->getNode()); } else { $stream_resource = librdf_model_find_statements($this->model, $statement); } if ($num_args > 2) { librdf_free_statement($statement); } if (!$stream_resource) { throw new LibRDF_Error("Unable to create new statement iterator"); } return new LibRDF_StreamIterator($stream_resource, $this); }
/** * Creates a new storage backend. * * The storage methods available depends on the librdf configuration. * Methods always available are `memory', `hashes', `file' and `uri'. * Optional methods are `bdb', `mysql' and `sqllite'. The default is * `memory'. * * The name argument is mandatory for storage methods that required a named * handle, such as file and URI. * * <code>$stor = new LibRDF_Storage(storage_name="file", name="/tmp/filename");</code> * * The options string passes storage_name specific options to the chosen * backend and uses the following form: * * <code>$stor = new LibRDF_Storage("storage_name", "name", * "key1='value1', key2='value2', ...");</code> * * Options values must be surrounded by single quotes for multiple * key/option pairs. * * The options common to all storage methods are: * new - optional boolean (default false) * If true, delete any existing store and create a new one, otherwise * open an existing store. * * write - optional boolean (default true) * If true, open the store in read-write mode. * * For hashes: * hash-type - the name of any supported hash type (default 'memory') * 'memory' and 'file' hash types are always present, and 'bdb' * may be available depending on compile-time configuration of * librdf. * * dir - (default '.') the directory in which to create files * * mode - (default 0644) the octal file mode with which to create files * * @param string $storage_name The type of storage to use * @param string $name A name for the storage handle * @param string $options Options for the storage backend * @return void * @throws LibRDF_Error If unable to create a new storage * @access public */ public function __construct($storage_name = "memory", $name = NULL, $options = NULL) { $this->storage = librdf_new_storage(librdf_php_get_world(), $storage_name, $name, $options); if (!$this->storage) { throw new LibRDF_Error("Unable to create storage"); } }