Context Navigation

source: Dev/trunk/rdfapi/syntax/RdfSerializer.php @ 12

Last change on this file since 12 was 12, checked in by basvannuland, 14 years ago
Added RAP RDF API Added RDF reader writer for save and load survey
File size: 20.2 KB

Rev	Line
[12]	1	<?php
	2
	3
	4	// ----------------------------------------------------------------------------------
	5	// Class: RdfSerializer
	6	// ----------------------------------------------------------------------------------
	7
	8	/**
	9	* An RDF seralizer.
	10	* Seralizes models to RDF syntax. It supports the xml:base, xml:lang, rdf:datatype and
	11	* rdf:nodeID directive.
	12	* You can choose between different output syntaxes by using the configuration methods
	13	* or changing the configuration default values in constants.php.
	14	* This class is based on the java class edu.unika.aifb.rdf.api.syntax.RDFSerializer by Boris Motik.
	15	*
	16	* @version $Id: RdfSerializer.php 316 2006-08-24 07:55:29Z tgauss $
	17	* @author Chris Bizer <chris@bizer.de>, Boris Motik <motik@fzi.de>, Daniel Westphal <dawe@gmx.de>, Leandro Mariano Lopez <llopez@xinergiaargentina.com>
	18	*
	19	* @package syntax
	20	* @access public
	21	*
	22	*/
	23	class RdfSerializer extends Object {
	24
	25	// configuration
	26	var $use_entities;
	27	var $use_attributes;
	28	var $sort_model;
	29	var $rdf_qnames;
	30	var $use_xml_declaration;
	31
	32	// properties
	33	var $m_defaultNamespaces = array();
	34	var $m_namespaces = array();
	35	var $m_nextAutomaticPrefixIndex;
	36	var $m_out;
	37	var $m_baseURI;
	38	var $m_statements = array();
	39	var $m_currentSubject;
	40	var $m_rdfIDElementText;
	41	var $m_rdfAboutElementText;
	42	var $m_rdfResourceElementText;
	43	var $m_groupTypeStatement;
	44	var $m_attributeStatements = array();
	45	var $m_contentStatements = array();
	46	var $rdf_qname_prefix;
	47
	48	/**
	49	* Constructor
	50	*
	51	* @access public
	52	*/
	53	function RdfSerializer() {
	54
	55	// default serializer configuration
	56	$this->use_entities = SER_USE_ENTITIES;
	57	$this->use_attributes = SER_USE_ATTRIBUTES;
	58	$this->sort_model = SER_SORT_MODEL;
	59	$this->rdf_qnames = SER_RDF_QNAMES;
	60	$this->use_xml_declaration = SER_XML_DECLARATION;
	61
	62	global $default_prefixes;
	63	foreach($default_prefixes as $key => $value){
	64	$this->addNamespacePrefix($key,$value);
	65	}
	66
	67	require_once(RDFAPI_INCLUDE_DIR.PACKAGE_UTILITY);
	68	}
	69
	70	/**
	71	* Serializer congiguration: Sort Model
	72	* Flag if the serializer should sort the model by subject before serializing.
	73	* TRUE makes the RDF code more compact.
	74	* TRUE is default. Default can be changed in constants.php.
	75	*
	76	* @param boolean
	77	* @access public
	78	*/
	79	function configSortModel($bool) {
	80	$this->sort_model = $bool;
	81	}
	82
	83	/**
	84	* Serializer congiguration: Use Entities
	85	* Flag if the serializer should use entities for URIs.
	86	* TRUE makes the RDF code more compact.
	87	* FALSE is default. Default can be changed in constants.php.
	88	*
	89	* @param boolean
	90	* @access public
	91	*/
	92	function configUseEntities($bool) {
	93	$this->use_entities = $bool;
	94	}
	95
	96	/**
	97	* Serializer congiguration: Use Attributes
	98	* Flag if the serializer should serialize triples as XML attributes where possible.
	99	* TRUE makes the RDF code more compact.
	100	* FALSE is default. Default can be changed in constants.php.
	101	*
	102	* @param boolean
	103	* @access public
	104	*/
	105	function configUseAttributes($bool) {
	106	$this->use_attributes = $bool;
	107	}
	108
	109	/**
	110	* Serializer congiguration: Use Qnames
	111	* Flag if the serializer should use qualified names for RDF reserved words.
	112	* TRUE makes the RDF code more compact.
	113	* TRUE is default. Default can be changed in constants.php.
	114	*
	115	* @param boolean
	116	* @access public
	117	*/
	118	function configUseQnames($bool) {
	119	$this->rdf_qnames = $bool;
	120	}
	121
	122	/**
	123	* Serializer congiguration: Use XML Declaration
	124	* Flag if the serializer should start documents with the xml declaration
	125	* <?xml version="1.0" encoding="UTF-8" ?>.
	126	* TRUE is default. Default can be changed in constants.php.
	127	*
	128	* @param boolean
	129	* @access public
	130	*/
	131	function configUseXmlDeclaration($bool) {
	132	$this->use_xml_declaration = $bool;
	133	}
	134
	135
	136	/**
	137	* Adds a new prefix/namespace combination.
	138	*
	139	* @param String $prefix
	140	* @param String $namespace
	141	* @access public
	142	*/
	143	function addNamespacePrefix($prefix, $namespace) {
	144	$this->m_defaultNamespaces[$prefix] = $namespace;
	145	}
	146
	147	/**
	148	* Serializes a model to RDF syntax.
	149	* RDF syntax can be changed by config_use_attributes($boolean), config_use_entities($boolean),
	150	* config_sort_model($boolean).
	151	* NOTE: There is only one default namespace allowed within an XML document.
	152	* Therefore if SER_RDF_QNAMES in constants.php is set to FALSE and you pass
	153	* another $xml_default_namespace as parameter, the model will be serialized
	154	* as if SER_RDF_QNAMES were set to TRUE.
	155	*
	156	* @param object MemModel $model
	157	* @param String $encoding
	158	* @return string
	159	* @access public
	160	*/
	161	function & serialize(&$model, $xml_default_namespace = NULL, $encoding = DEFAULT_ENCODING) {
	162
	163	if ($xml_default_namespace) {
	164
	165	if ($xml_default_namespace == RDF_NAMESPACE_URI) {
	166	$this->rdf_qnames = FALSE;
	167	unset($this->m_defaultNamespaces[RDF_NAMESPACE_PREFIX]);
	168	}
	169	elseif ($xml_default_namespace == RDF_SCHEMA_URI) {
	170	unset($this->m_defaultNamespaces[RDF_SCHEMA_PREFIX]);
	171	}
	172	elseif (!SER_RDF_QNAMES)
	173	$this->rdf_qnames = TRUE;
	174
	175	$this->addNamespacePrefix(NULL, $xml_default_namespace);
	176	}
	177
	178	//copy parsed namespaces
	179	$nsps = array();
	180	$nsps = $model->getParsedNamespaces();
	181	foreach($this->m_defaultNamespaces as $prefix => $namespace){
	182	if(!isset ($nsps[$namespace]))
	183	$nsps[$namespace] = $prefix;
	184	}
	185
	186	// define rdf prefix (qname or not)
	187	if ($this->rdf_qnames){
	188	if(isset($nsps[RDF_NAMESPACE_URI])){
	189	$this->rdf_qname_prefix = $nsps[RDF_NAMESPACE_URI].':';
	190	}else{
	191	$this->rdf_qname_prefix = RDF_NAMESPACE_PREFIX . ':';
	192	}
	193
	194	}else{
	195	$this->rdf_qname_prefix = '';
	196	}
	197	// check if model is empty
	198	if ($model->size() == 0) return "<". $this->rdf_qname_prefix . RDF_RDF ." xmlns:rdf='".RDF_NAMESPACE_URI."' />";
	199
	200	foreach($nsps as $ns => $pre){
	201	$this->m_namespaces[$pre] = $ns;
	202	}
	203
	204
	205	// set base URI
	206	if ($model->getBaseURI()==NULL)
	207	$this->m_baseURI="opaque:uri";
	208	else
	209	$this->m_baseURI=$model->getBaseURI();
	210
	211
	212	if ($this->sort_model) {
	213	// sort the array of statements
	214
	215	foreach($model->triples as $key => $statement) {
	216	$stmkey = $statement->subj->getURI() .
	217	$statement->pred->getURI() .
	218	(is_a($statement->obj,'Literal')?'"'.$statement->obj->getLabel().'"@'.$statement->obj->getLanguage().'^^'.$statement->obj->getDatatype():$statement->obj->getURI());
	219	$this->m_statements[$stmkey] = $statement;
	220	}
	221	ksort($this->m_statements);
	222
	223	/*
	224	// Sort using the PHP usort() function. Slower :-(
	225	$this->m_statements = $model->triples;
	226	usort($this->m_statements, "statementsorter");
	227	*/
	228	} else {
	229	$this->m_statements = $model->triples;
	230	}
	231	// collects namespaces
	232	$this->m_nextAutomaticPrefixIndex=0;
	233	$this->collectNamespaces($model);
	234
	235	// start writing the contents
	236	$this->m_out="";
	237	if ($this->use_xml_declaration)
	238	$this->m_out .= '<?xml version="1.0" encoding="' . $encoding . '" ?>' . LINEFEED;
	239	if (!HIDE_ADVERTISE)
	240	$this->m_out.="<!-- Generated by RdfSerializer.php from RDF RAP.".LINEFEED."# http://www.wiwiss.fu-berlin.de/suhl/bizer/rdfapi/index.html !-->".LINEFEED.LINEFEED ;
	241
	242	// write entitie declarations
	243	if($this->use_entities) {
	244	$this->m_out .= '<!DOCTYPE ' . $this->rdf_qname_prefix .
	245	RDF_RDF.' [' . LINEFEED;
	246	$this->writeEntityDeclarations();
	247	$this->m_out .= LINEFEED . ']>' . LINEFEED;
	248	}
	249
	250	// start the RDF text
	251	$this->m_out .= '<' . $this->rdf_qname_prefix . RDF_RDF;
	252
	253	// write the xml:base
	254	if ($model->getBaseURI() != NULL)
	255	$this->m_out .= LINEFEED. INDENTATION .'xml:base="'.$model->getBaseURI().'"';
	256
	257	// write namespaces declarations
	258	$this->writeNamespaceDeclarations();
	259	$this->m_out .='>'. LINEFEED;
	260
	261	// write triples
	262	$this->writeDescriptions();
	263
	264	$this->m_out .= LINEFEED;
	265	$this->m_out .='</' . $this->rdf_qname_prefix . RDF_RDF .'>';
	266
	267	$this->m_namespaces=null;
	268	$this->m_statements=null;
	269	$this->m_currentSubject=null;
	270	$this->m_groupTypeStatement=null;
	271	$this->m_attributeStatements=null;
	272	$this->m_contentStatements=null;
	273	$this->m_rdfResourceElementText=null;
	274
	275	return $this->m_out;
	276	}
	277
	278	/**
	279	* Serializes a model and saves it into a file.
	280	* Returns FALSE if the model couldn't be saved to the file.
	281	*
	282	* @param object MemModel $model
	283	* @param String $encoding
	284	* @return boolean
	285	* @access public
	286	*/
	287	function saveAs(&$model, $filename, $encoding = DEFAULT_ENCODING) {
	288	// serialize model
	289	$RDF = $this->serialize($model, NULL, $encoding);
	290
	291	//write serialized model to file
	292	$file_handle = @fopen($filename, 'w');
	293	if ($file_handle) {
	294	fwrite($file_handle, $RDF);
	295	fclose($file_handle);
	296	return TRUE;
	297	} else {
	298	return FALSE;
	299	};
	300	}
	301
	302	/**
	303	* @access private
	304	*/
	305	function writeEntityDeclarations() {
	306	foreach($this->m_namespaces as $prefix => $namespace) {
	307	$this->m_out .= INDENTATION . '<!ENTITY '. $prefix . " '" . $namespace ."'>".LINEFEED;
	308	}
	309	}
	310
	311	/**
	312	* @access private
	313	*/
	314	function writeNamespaceDeclarations() {
	315	foreach($this->m_namespaces as $prefix => $namespace) {
	316
	317	if ($prefix == RDF_NAMESPACE_PREFIX && !$this->rdf_qnames) {
	318
	319	if($this->use_entities) {
	320	$this->m_out .= LINEFEED . INDENTATION .XML_NAMESPACE_DECLARATION_PREFIX .
	321	'="&' . $prefix . ';"';
	322	} else {
	323	$this->m_out .= LINEFEED . INDENTATION .XML_NAMESPACE_DECLARATION_PREFIX .
	324	'="' . $namespace . '"';
	325	}
	326	} else {
	327	if ($prefix == NULL)
	328	$colon_prefix = $prefix;
	329	else
	330	$colon_prefix = ":" .$prefix;
	331
	332	if($this->use_entities) {
	333	$this->m_out .= LINEFEED . INDENTATION .XML_NAMESPACE_DECLARATION_PREFIX
	334	.$colon_prefix .'="&' . $prefix . ';"';
	335	} else {
	336	$this->m_out .= LINEFEED . INDENTATION .XML_NAMESPACE_DECLARATION_PREFIX
	337	.$colon_prefix .'="' . $namespace . '"';
	338	}
	339	}
	340	}
	341	}
	342
	343	/**
	344	* @access private
	345	*/
	346	function writeDescriptions() {
	347
	348	$this->m_groupTypeStatement = NULL;
	349	$this->m_attributeStatements = array();
	350	$this->m_contentStatements = array();
	351	$this->m_currentSubject = NULL;
	352
	353	foreach($this->m_statements as $key => $statement) {
	354	$subject = $statement->getSubject();
	355	$predicate = $statement->getPredicate();
	356	$object = $statement->getobject();
	357
	358	// write Group and update current subject if nessesary
	359	if ($this->m_currentSubject==NULL \|\| !$this->m_currentSubject->equals($subject)) {
	360	$this->writeGroup();
	361	$this->m_currentSubject=$subject;
	362	}
	363
	364	// classify the statement
	365	if (($predicate->getURI() == RDF_NAMESPACE_URI.RDF_TYPE) && is_a($object, 'Resource') && !$this->m_groupTypeStatement) {
	366	$this->writeGroup();
	367	$this->m_groupTypeStatement = $statement;
	368	}
	369	elseif ($this->canAbbreviateValue($object) &&
	370	$this->use_attributes &&
	371	$this->checkForDoubleAttributes($predicate))
	372	{
	373	if (is_a($object, 'Literal')) {
	374	if ($object->getDatatype() == NULL) {
	375	$this->m_attributeStatements[] = $statement;
	376	} else {
	377	$this->m_contentStatements[] = $statement;
	378	}
	379	} else {
	380	$this->m_attributeStatements[] = $statement;
	381	}
	382	} else {
	383	$this->m_contentStatements[] = $statement;
	384	}
	385	}
	386	$this->writeGroup();
	387	}
	388
	389	/**
	390	* @access private
	391	*/
	392	function writeGroup() {
	393	if ($this->m_currentSubject==NULL \|\| ($this->m_groupTypeStatement==NULL && (count($this->m_attributeStatements)==0) && (count($this->m_contentStatements)==0)))
	394	return;
	395	if ($this->m_groupTypeStatement!=NULL)
	396	$outerElementName=$this->getElementText($this->m_groupTypeStatement->obj->getURI());
	397	else
	398	$outerElementName = $this->rdf_qname_prefix . RDF_DESCRIPTION;
	399	$this->m_out .= LINEFEED . '<';
	400	$this->m_out .= $outerElementName;
	401
	402	$this->m_out .= ' ';
	403
	404
	405	$this->writeSubjectURI($this->m_currentSubject);
	406
	407	// attribute Statements
	408	if ($this->use_attributes)
	409	$this->writeAttributeStatements();
	410
	411	if (count($this->m_contentStatements)==0)
	412	$this->m_out .= '/>' . LINEFEED;
	413	else {
	414	$this->m_out .= '>' . LINEFEED;
	415
	416	// content statements
	417	$this->writeContentStatements();
	418
	419	$this->m_out .= '</';
	420	$this->m_out .= $outerElementName;
	421	$this->m_out .= '>'. LINEFEED;
	422	}
	423	$this->m_groupTypeStatement = NULL;
	424	$this->m_attributeStatements = array();
	425	$this->m_contentStatements = array();
	426	}
	427
	428	/**
	429	* @param object Node $predicate
	430	* @access private
	431	*/
	432	function checkForDoubleAttributes($predicate) {
	433	foreach($this->m_attributeStatements as $key => $statement) {
	434	if ($statement->pred->equals($predicate))
	435	return FALSE;
	436	}
	437	return TRUE;
	438	}
	439
	440	/**
	441	* @param STRING $uri
	442	* @access private
	443	*/
	444	function relativizeURI($uri) {
	445	$rdfUtil=new RDFUtil();
	446	$uri_namespace = $rdfUtil->guessNamespace($uri);
	447	if ($uri_namespace == $this->m_baseURI) {
	448	return $rdfUtil->guessName($uri);
	449	} else {
	450	return $uri;
	451	}
	452	}
	453
	454	/**
	455	* @param object Node $subject_node
	456	*
	457	* @access private
	458	*/
	459
	460	function writeSubjectURI($subject_node) {
	461	$currentSubjectURI = $subject_node->getURI();
	462	$relativizedURI = $this->relativizeURI($currentSubjectURI);
	463
	464	// if submitted subject ist a blank node, use rdf:nodeID
	465	if (is_a($this->m_currentSubject, 'BlankNode')) {
	466	$this->m_out .= $this->rdf_qname_prefix . RDF_NODEID;
	467	$this->m_out .= '="';
	468	$this->m_out .= $relativizedURI;
	469	} else {
	470
	471
	472	if (!($relativizedURI == $currentSubjectURI)) {
	473	$this->m_out .= $this->rdf_qname_prefix . RDF_ID;
	474	$this->m_out .= '="';
	475	$this->m_out .= $relativizedURI;
	476	} else {
	477	$this->m_out .= $this->rdf_qname_prefix . RDF_ABOUT;
	478	$this->m_out .= '="';
	479	$this->writeAbsoluteResourceReference($relativizedURI);
	480	};
	481	};
	482	$this->m_out .= '"';
	483	}
	484
	485	/**
	486	* @access private
	487	*/
	488	function writeAttributeStatements() {
	489	foreach($this->m_attributeStatements as $key => $statement) {
	490	$this->m_out .= LINEFEED;
	491	$this->m_out .= INDENTATION;
	492	$this->m_out .= $this->getElementText($statement->pred->getURI());
	493	$this->m_out .= '=';
	494	$value=$statement->obj->getLabel();
	495	$quote=$this->getValueQuoteType($value);
	496	$this->m_out .= $quote;
	497	$this->m_out .= $value;
	498	$this->m_out .= $quote;
	499	}
	500	}
	501
	502	/**
	503	* @access private
	504	*/
	505	function writeContentStatements() {
	506	foreach($this->m_contentStatements as $key => $statement) {
	507	$this->m_out .= INDENTATION;
	508	$this->m_out .= '<';
	509	$predicateElementText=$this->getElementText($statement->pred->getURI());
	510	$this->m_out .= $predicateElementText;
	511
	512	if (is_a($statement->obj, 'Resource')) {
	513	$this->writeResourceReference($statement->obj);
	514	$this->m_out .= '/>' . LINEFEED;
	515	} else {
	516	if(is_a($statement->obj, 'Literal')) {
	517	if ($statement->obj->getDatatype()!= NULL)
	518	if ($statement->obj->getDatatype()== RDF_NAMESPACE_URI . RDF_XMLLITERAL) {
	519	$this->m_out .= ' ' . RDF_NAMESPACE_PREFIX . ':' . RDF_PARSE_TYPE . '="' . RDF_PARSE_TYPE_LITERAL . '"';
	520	} else {
	521	$this->m_out .= ' ' . RDF_NAMESPACE_PREFIX . ':' . RDF_DATATYPE . '="' . $statement->obj->getDatatype() . '"';
	522	}
	523	if ($statement->obj->getLanguage()!= NULL)
	524	$this->m_out .= ' ' . XML_NAMESPACE_PREFIX . ':' . XML_LANG . '="' . $statement->obj->getLanguage() . '"';
	525	};
	526	$this->m_out .= '>';
	527	if ($statement->obj->getDatatype()== RDF_NAMESPACE_URI . RDF_XMLLITERAL) {
	528	$this->m_out .= $statement->obj->getLabel();
	529	} else {
	530	$this->writeTextValue($statement->obj->getLabel());
	531	}
	532	$this->m_out .= '</';
	533	$this->m_out .= $predicateElementText;
	534	$this->m_out .= '>' . LINEFEED;
	535	}
	536	}
	537	}
	538
	539	/**
	540	* @param Object $object_node
	541	* @access private
	542	*/
	543	function writeResourceReference($object_node) {
	544	$rebaseURI = $object_node->getURI();
	545	$this->m_out .= ' ';
	546	if (is_a($object_node, 'BlankNode')) {
	547	$this->m_out .= $this->rdf_qname_prefix . RDF_NODEID;
	548	} else {
	549	$this->m_out .= $this->rdf_qname_prefix . RDF_RESOURCE;
	550	};
	551
	552	$this->m_out .= '="';
	553	$relativizedURI = $this->relativizeURI($rebaseURI);
	554	if (!($relativizedURI == $rebaseURI))
	555	if (!is_a($object_node, 'BlankNode'))
	556	$this->m_out .= '#' . $relativizedURI;
	557	else
	558	$this->m_out .= $relativizedURI;
	559	else
	560	$this->writeAbsoluteResourceReference($rebaseURI);
	561	$this->m_out .= '"';
	562	}
	563
	564
	565	/**
	566	* @param String $rebaseURI
	567	* @access private
	568	*/
	569	function writeAbsoluteResourceReference($rebaseURI) {
	570	$rdfUtil=new RDFUtil();
	571	$namespace=$rdfUtil->guessNamespace($rebaseURI);
	572	$localName=$rdfUtil->guessName($rebaseURI);
	573	$text=$rebaseURI;
	574	if ($namespace!='' and $this->use_entities) {
	575	$prefix= array_search($namespace, $this->m_namespaces);
	576	$text='&'.$prefix.';'.$localName;
	577	} else $text = $rdfUtil->escapeValue($text);
	578	$this->m_out .= $text;
	579	}
	580
	581	/**
	582	* @param STRING $textValue
	583	* @access private
	584	*/
	585	function writeTextValue($textValue) {
	586	if ($this->getValueQuoteType($textValue)==USE_CDATA)
	587	$this->writeEscapedCDATA($textValue);
	588	else
	589	$this->m_out .= $textValue;
	590	}
	591
	592	/**
	593	* @param STRING $textValue
	594	* @access private
	595	*/
	596	function writeEscapedCDATA($textValue) {
	597	$this->m_out .= '<![CDATA[' . $textValue . ']]>';
	598	}
	599
	600	/**
	601	* @param STRING $textValue
	602	* @access private
	603	*/
	604	function getValueQuoteType($textValue) {
	605	$quote=USE_ANY_QUOTE;
	606	$hasBreaks=FALSE;
	607	$whiteSpaceOnly=TRUE;
	608	for ($i=0; $i<strlen($textValue); $i++) {
	609	$c=$textValue{$i};
	610	if ($c=='<' \|\| $c=='>' \|\| $c=='&')
	611	return USE_CDATA;
	612	if ($c==LINEFEED)
	613	$hasBreaks=TRUE;
	614	if ($c=='"' \|\| $c=="\'") {
	615	if ($quote==USE_ANY_QUOTE)
	616	$quote=($c=='"') ? "\'" : "\"";
	617	elseif ($c==$quote)
	618	return USE_CDATA;
	619	}
	620	if (!($c == ' '))
	621	$whiteSpaceOnly = FALSE;
	622	}
	623	if ($whiteSpaceOnly \|\| $hasBreaks)
	624	return USE_CDATA;
	625	return $quote==USE_ANY_QUOTE ? '"' : $quote;
	626	}
	627
	628	/**
	629	* @param object Node $node
	630	* @access private
	631	*/
	632	function canAbbreviateValue($node) {
	633	if (is_a($node, 'Literal')) {
	634	$value= $node->getLabel();
	635	if (strlen($value)<MAX_ALLOWED_ABBREVIATED_LENGTH) {
	636	$c=$this->getValueQuoteType($value);
	637	return $c=='"' \|\| $c=='\'';
	638	}
	639	}
	640	return FALSE;
	641	}
	642
	643	/**
	644	* @param STRING $elementName
	645	* @access private
	646	*/
	647	function getElementText($elementName) {
	648	$rdfUtil=new RDFUtil();
	649	$namespace=$rdfUtil->guessNamespace($elementName);
	650	$localName=$rdfUtil->guessName($elementName);
	651	if ($namespace=="")
	652	return $localName;
	653	$prefix=array_search($namespace, $this->m_namespaces);
	654
	655	if ($prefix===FALSE) {
	656	$errmsg = RDFAPI_ERROR . "(class: Serializer; method: getElementText): Prefix for element '" . $elementName . "' cannot be found.";
	657	trigger_error($errmsg, E_USER_ERROR);
	658	}
	659	switch ($prefix) {
	660	case RDF_NAMESPACE_PREFIX:
	661	return $this->rdf_qname_prefix . $localName;
	662	case NULL:
	663	return $localName;
	664	default:
	665	return $prefix. ":" .$localName;
	666	}
	667	}
	668
	669	/**
	670	* @param object MemModel $model
	671	* @access private
	672	*/
	673	function collectNamespaces($model) {
	674	foreach($model->triples as $key => $value) {
	675
	676	if ($this->use_entities) {
	677	$this->collectNamespace($value->getSubject());
	678	if(!is_a($value->getObject(), 'Literal'))
	679	$this->collectNamespace($value->getObject());
	680
	681	} else {
	682
	683	if ($value->pred->getURI() == RDF_NAMESPACE_URI.RDF_TYPE)
	684	$this->collectNamespace($value->getObject());
	685	elseif
	686	(($value->pred->getURI() == RDF_NAMESPACE_URI.RDFS_SUBCLASSOF) \|\|
	687	($value->pred->getURI() == RDF_NAMESPACE_URI.RDFS_SUBPROPERTYOF)) {
	688	$this->collectNamespace($value->getSubject());
	689	$this->collectNamespace($value->getObject());
	690	}
	691	}
	692
	693	$this->collectNamespace($value->getPredicate());
	694
	695	}
	696	}
	697
	698	/**
	699	* @param object Resource $resource
	700	* @access private
	701	*/
	702	function collectNamespace($resource) {
	703
	704	$rdfUtil=new RDFUtil();
	705	$namespace=$rdfUtil->getNamespace($resource);
	706	if (!in_array($namespace, $this->m_namespaces)&&$namespace!='') {
	707	$prefix = array_search( $namespace, $this->m_defaultNamespaces);
	708	if ($prefix===FALSE)
	709	$prefix=$this->getNextNamespacePrefix();
	710	$this->m_namespaces[$prefix] = $namespace;
	711	}
	712	}
	713
	714	/**
	715	* @access private
	716	*/
	717	function getNextNamespacePrefix() {
	718	$this->m_nextAutomaticPrefixIndex++;
	719	return GENERAL_PREFIX_BASE . $this->m_nextAutomaticPrefixIndex;
	720	}
	721
	722	}
	723	?>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: