Context Navigation

source: Dev/trunk/rdfapi/model/MemModel.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: 37.5 KB

Rev	Line
[12]	1	<?php
	2	require_once RDFAPI_INCLUDE_DIR . 'model/Model.php';
	3	// ----------------------------------------------------------------------------------
	4	// Class: MemModel
	5	// ----------------------------------------------------------------------------------
	6
	7	/**
	8	* A MemModel is an RDF Model, which is stored in the main memory.
	9	* This class provides methods for manipulating MemModels.
	10	*
	11	*
	12	*
	13	* @version $Id: MemModel.php 425 2007-05-01 12:59:18Z cweiske $
	14	* @author Chris Bizer <chris@bizer.de>
	15	* @author Gunnar AAstrand Grimnes <ggrimnes@csd.abdn.ac.uk>
	16	* @author Radoslaw Oldakowski <radol@gmx.de>
	17	* @author Daniel Westphal <mail@d-westphal.de>
	18	* @author Tobias GauÃ <tobias.gauss@web.de>
	19	*
	20	* @package model
	21	* @access public
	22	*/
	23
	24	class MemModel extends Model {
	25
	26	/**
	27	* Triples of the MemModel
	28	* @var array
	29	* @access private
	30	*/
	31	var $triples = array();
	32
	33	/**
	34	* Array containing the search indices
	35	* @var array['INDEX_TYPE'][]['label'][]['PosInModel']
	36	*
	37	* @access private
	38	*/
	39	var $indexArr ;
	40
	41
	42	/**
	43	* depending on which index is used this variable is -1,0,1,2 or 3
	44	*
	45	* -1 : no index
	46	* 0 : default indices over subject, predicate, object separate
	47	* 1 : index over subject+predicate+object
	48	* 2 : index over subject+predicate
	49	* 3 : index over subject+object
	50	*
	51	* @var int
	52	* @access private
	53	*/
	54	var $indexed;
	55
	56
	57
	58	/**
	59	* Array of namespaces
	60	*
	61	* @var array
	62	* @access private
	63	*/
	64	var $parsedNamespaces=array();
	65
	66
	67
	68	/**
	69	* Constructor
	70	* You can supply a base_uri
	71	*
	72	* @param string $baseURI
	73	* @access public
	74	*/
	75	function MemModel($baseURI = NULL) {
	76	$this->setBaseURI($baseURI);
	77	$this->indexed = INDEX_TYPE;
	78	}
	79
	80	/**
	81	* Set a base URI for the MemModel.
	82	* Affects creating of new resources and serialization syntax.
	83	* If the URI doesn't end with # : or /, then a # is added to the URI.
	84	* @param string $uri
	85	* @access public
	86	*/
	87	function setBaseURI($uri) {
	88
	89	if ($uri != NULL) {
	90	$c = substr($uri, strlen($uri)-1 ,1);
	91	if (!($c=='#' \|\| $c==':' \|\| $c=='/' \|\| $c=="\\"))
	92	$uri .= '#';
	93	}
	94	$this->baseURI = $uri;
	95	}
	96
	97
	98	/**
	99	* Number of triples in the MemModel
	100	*
	101	* @return integer
	102	* @access public
	103	*/
	104	function size() {
	105	return count($this->triples);
	106	}
	107
	108	/**
	109	* Checks if MemModel is empty
	110	*
	111	* @return boolean
	112	* @access public
	113	*/
	114	function isEmpty() {
	115	if (count($this->triples) == 0) {
	116	return TRUE;
	117	} else {
	118	return FALSE;
	119	};
	120	}
	121
	122
	123	/**
	124	* Adds a new triple to the MemModel without checking if the statement is already in the MemModel.
	125	* So if you want a duplicate free MemModel use the addWithoutDuplicates() function (which is slower then add())
	126	*
	127	* @param object Statement $statement
	128	* @access public
	129	* @throws PhpError
	130	*/
	131	function add($statement) {
	132	if (!is_a($statement, 'Statement')) {
	133	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: add): Statement expected.';
	134	trigger_error($errmsg, E_USER_ERROR);
	135	}
	136
	137	if($this->indexed != -1){
	138	$this->triples[] = $statement;
	139	end($this->triples);
	140	$k=key($this->triples);
	141	if($this->indexed==0){
	142	// index over S
	143	$this->_indexOpr($statement,$k,4,1);
	144	// index over P
	145	$this->_indexOpr($statement,$k,5,1);
	146	// index over O
	147	$this->_indexOpr($statement,$k,6,1);
	148	}else{
	149	$this->_indexOpr($statement,$k,$this->indexed,1);
	150	}
	151
	152	}else{
	153	$this->triples[] = $statement;
	154	}
	155	}
	156
	157
	158
	159	/**
	160	* Checks if a new statement is already in the MemModel and adds the statement, if it is not in the MemModel.
	161	* addWithoutDuplicates() is significantly slower then add().
	162	* Retruns TRUE if the statement is added.
	163	* FALSE otherwise.
	164	*
	165	* @param object Statement $statement
	166	* @return boolean
	167	* @access public
	168	* @throws PhpError
	169	*/
	170	function addWithoutDuplicates($statement) {
	171
	172	if (!is_a($statement, 'Statement')) {
	173	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: addWithoutDuplicates): Statement expected.';
	174	trigger_error($errmsg, E_USER_ERROR);
	175	}
	176
	177	if (!$this->contains($statement)) {
	178	$this->add($statement);
	179	return true;
	180	}else{
	181	return false;
	182	}
	183	}
	184
	185	/**
	186	* Removes the triple from the MemModel.
	187	* TRUE if the triple is removed.
	188	* FALSE otherwise.
	189	*
	190	* @param object Statement $statement
	191	* @return boolean
	192	* @access public
	193	* @throws PhpError
	194	*/
	195	function remove($statement) {
	196
	197	if (!is_a($statement, 'Statement')) {
	198	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: remove): Statement expected.';
	199	trigger_error($errmsg, E_USER_ERROR);
	200	}
	201	if($this->indexed==-1){
	202	$pass=false;
	203	foreach($this->triples as $key => $value) {
	204	if ($this->matchStatement($value, $statement->subject(), $statement->predicate(), $statement->object())) {
	205	unset($this->triples[$key]);
	206	$pass= true;
	207	}
	208	}
	209	return $pass;
	210	}else{
	211	$k= null;
	212	if($this->indexed==0){
	213	$pass=false;
	214	$del=false;
	215	while($del!=-1){
	216	// index over S
	217	$del=$this->_indexOpr($statement,$k,4,0);
	218	// index over P
	219	$this->_indexOpr($statement,$k,5,0);
	220	// index over O
	221	$this->_indexOpr($statement,$k,6,0);
	222	if($del!=-1){
	223	unset($this->triples[$del]);
	224	$pass=true;
	225	}
	226	}
	227	return $pass;
	228	}else{
	229	$pass=false;
	230	$del=false;
	231	while($del!=-1){
	232	$del=$this->_indexOpr($statement,$k,$this->indexed,0);
	233	if($del!=-1){
	234	unset($this->triples[$del]);
	235	$pass=true;
	236	}
	237	}
	238	return $pass;
	239	}
	240	}
	241	}
	242
	243	/**
	244	* Short Dump of the MemModel.
	245	*
	246	* @access public
	247	* @return string
	248	*/
	249	function toString() {
	250	return 'MemModel[baseURI=' . $this->getBaseURI() . '; size=' . $this->size() . ']';
	251	}
	252
	253	/**
	254	* Dumps of the MemModel including all triples.
	255	*
	256	* @access public
	257	* @return string
	258	*/
	259	function toStringIncludingTriples() {
	260	$dump = $this->toString() . chr(13);
	261	foreach($this->triples as $value) {
	262	$dump .= $value->toString() . chr(13);
	263	}
	264	return $dump;
	265	}
	266
	267
	268
	269
	270	/**
	271	* Writes the RDF serialization of the MemModel as HTML.
	272	*
	273	* @access public
	274	*/
	275	function writeAsHtml() {
	276	require_once(RDFAPI_INCLUDE_DIR.PACKAGE_SYNTAX_RDF);
	277	$ser = new RdfSerializer();
	278	$rdf =& $ser->serialize($this);
	279	$rdf = htmlspecialchars($rdf, ENT_QUOTES);
	280	$rdf = str_replace(' ', ' ', $rdf);
	281	$rdf = nl2br($rdf);
	282	echo $rdf;
	283	}
	284
	285	/**
	286	* Writes the RDF serialization of the MemModel as HTML table.
	287	*
	288	* @access public
	289	*/
	290	function writeAsHtmlTable() {
	291	// Import Package Utility
	292	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_UTILITY);
	293	$rdfUtil = new RDFUtil();
	294	$rdfUtil->writeHTMLTable($this);
	295	}
	296
	297
	298	/**
	299	* Writes the RDF serialization of the MemModel as HTML table.
	300	*
	301	* @access public
	302	* @return string
	303	*/
	304	function writeRdfToString() {
	305	// Import Package Syntax
	306	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_SYNTAX_RDF);
	307	$ser = new RdfSerializer();
	308	$rdf =& $ser->serialize($this);
	309	return $rdf;
	310	}
	311
	312
	313	/**
	314	* Saves the RDF,N3 or N-Triple serialization of the MemModel to a file.
	315	* You can decide to which format the model should be serialized by using a
	316	* corresponding suffix-string as $type parameter. If no $type parameter
	317	* is placed this method will serialize the model to XML/RDF format.
	318	* Returns FALSE if the MemModel couldn't be saved to the file.
	319	*
	320	* @access public
	321	* @param string $filename
	322	* @param string $type
	323	* @throws PhpError
	324	* @return boolean
	325	*/
	326	function saveAs($filename, $type ='rdf') {
	327
	328
	329	// get suffix and create a corresponding serializer
	330	if ($type=='rdf') {
	331	// Import Package Syntax
	332	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_SYNTAX_RDF);
	333	$ser=new RdfSerializer();
	334	}elseif ($type=='nt') {
	335	// Import Package Syntax
	336	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_SYNTAX_N3);
	337	$ser=new NTripleSerializer();
	338	}elseif ($type=='n3') {
	339	// Import Package Syntax
	340	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_SYNTAX_N3);
	341	$ser=new N3Serializer();
	342	}else {
	343	print ('Serializer type not properly defined. Use the strings "rdf","n3" or "nt".');
	344	return false;
	345	};
	346
	347	return $ser->saveAs($this, $filename);
	348	}
	349
	350
	351	/**
	352	* Tests if the MemModel contains the given triple.
	353	* TRUE if the triple belongs to the MemModel;
	354	* FALSE otherwise.
	355	*
	356	* @param object Statement &$statement
	357	* @return boolean
	358	* @access public
	359	*/
	360	function contains(&$statement) {
	361
	362	// no index ->linear contains
	363	if ($this->indexed==-1){
	364	foreach($this->triples as $value) {
	365	if ($value->equals($statement)){
	366	return TRUE; }
	367	}
	368	return false;
	369	}
	370	if ($this->indexed==0){
	371	$res = $this->_containsIndex($statement,4);
	372	return $res;
	373	}else{
	374	return $this->_containsIndex($statement,$this->indexed);
	375	}
	376	}
	377
	378
	379	/**
	380	* Determine if all of the statements in a model are also contained in this MemModel.
	381	* True if all of the statements in $model are also contained in this MemModel and false otherwise.
	382	*
	383	* @param object Model &$model
	384	* @return boolean
	385	* @access public
	386	*/
	387	function containsAll(&$model) {
	388
	389	if (is_a($model, 'MemModel')) {
	390
	391	foreach($model->triples as $statement)
	392	if(!$this->contains($statement))
	393	return FALSE;
	394	return TRUE;
	395
	396	}elseif (is_a($model, 'DbModel'))
	397
	398	return $model->containsAll($this);
	399
	400	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: containsAll): Model expected.';
	401	trigger_error($errmsg, E_USER_ERROR);
	402	}
	403
	404	/**
	405	* Determine if any of the statements in a model are also contained in this MemModel.
	406	* True if any of the statements in $model are also contained in this MemModel and false otherwise.
	407	*
	408	* @param object Model &$model
	409	* @return boolean
	410	* @access public
	411	*/
	412	function containsAny(&$model) {
	413
	414	if (is_a($model, 'MemModel')) {
	415
	416	foreach($model->triples as $modelStatement)
	417	if($this->contains($modelStatement))
	418	return TRUE;
	419	return FALSE;
	420
	421	}elseif (is_a($model, 'DbModel'))
	422
	423	return $model->containsAny($this);
	424
	425	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: containsAll): Model expected.';
	426	trigger_error($errmsg, E_USER_ERROR);
	427	}
	428
	429
	430	/**
	431	* Builds a search index for the statements in the MemModel.
	432	* The index is used by the find(),contains(),add() and remove() functions.
	433	* Performance example using a model with 43000 statements on a Linux machine:
	434	* Find without index takes 1.7 seconds.
	435	* Indexing takes 1.8 seconds.
	436	* Find with index takes 0.001 seconds.
	437	* So if you want to query a model more then once, build a index first.
	438	* The defaultindex is indices over subject, predicate, object seperate.
	439	*
	440	* mode = 0 : indices over subject,predicate,object (default)
	441	* mode = 1 : index over subject+predicate+object
	442	* mode = 2 : index over subject+predicate
	443	* mode = 3 : index over subject+object
	444	*
	445	* @param int $mode
	446	* @access public
	447	*/
	448	function index($mode) {
	449
	450	unset($this->indexArr);
	451	$this->indexArr=array();
	452	switch($mode){
	453	// unset indices
	454	case -1:
	455	$this->indexed=-1;
	456	unset($this->indexArr);
	457	break;
	458	// index over SPO
	459	case 0:
	460	$this->indexed=0;
	461	foreach($this->triples as $k => $t) {
	462	// index over S
	463	$this->_indexOpr($t,$k,4,1);
	464	// index over P
	465	$this->_indexOpr($t,$k,5,1);
	466	// index over O
	467	$this->_indexOpr($t,$k,6,1);
	468	}
	469	break;
	470	default:
	471	$this->indexed=$mode;
	472	foreach($this->triples as $k => $t) {
	473	$this->_indexOpr($t,$k,$this->indexed,1);
	474	}
	475	break;
	476	}
	477	}
	478
	479
	480	/**
	481	* Returns true if there is an index, false if not.
	482	*
	483	* @return boolean
	484	* @access public
	485	*/
	486	function isIndexed() {
	487	if($this->indexed!=-1){
	488	return TRUE;
	489	}else{
	490	return FALSE;
	491	}
	492	}
	493
	494	/**
	495	* Returns the indextype:
	496	* -1 if there is no index, 0 if there are indices over S,P,O(separate),
	497	* 1 if there is an index over SPO, 2 if there is an index over SP and 3 if
	498	* there is an index over SO.
	499	*
	500	* @return int
	501	* @access public
	502	*
	503	*/
	504	function getIndexType(){
	505	return $this->indexed;
	506	}
	507
	508	/**
	509	* General method to search for triples.
	510	* NULL input for any parameter will match anything.
	511	* Example: $result = $m->find( NULL, NULL, $node );
	512	* Finds all triples with $node as object.
	513	* Returns an empty MemModel if nothing is found.
	514	*
	515	* @param object Node $subject
	516	* @param object Node $predicate
	517	* @param object Node $object
	518	* @return object MemModel
	519	* @access public
	520	* @throws PhpError
	521	*/
	522
	523	function find($subject,$predicate,$object) {
	524
	525	if (
	526	(!is_a($subject, 'Resource') && $subject != NULL) \|\|
	527	(!is_a($predicate, 'Resource') && $predicate != NULL) \|\|
	528	(!is_a($object, 'Node') && $object != NULL)
	529	) {
	530	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: find): Parameters must be subclasses of Node or NULL';
	531	trigger_error($errmsg, E_USER_ERROR);
	532	}
	533
	534	$res = new MemModel($this->getBaseURI());
	535	$res->indexed=-1;
	536
	537	if($this->isEmpty())
	538	return $res;
	539
	540	if($subject == NULL && $predicate == NULL && $object == NULL)
	541	return $this;
	542
	543	switch($this->indexed){
	544	case 1:
	545	if($subject!=NULL && $predicate != NULL && $object != NULL){
	546	$pos=$subject->getLabel().$predicate->getLabel().$object->getLabel();
	547	return $this->_findInIndex($pos,$subject,$predicate,$object,1);
	548	}else{
	549	break;
	550	}
	551
	552	case 2:
	553	if($subject!=NULL && $predicate != NULL){
	554	$pos=$subject->getLabel().$predicate->getLabel();
	555	return $this->_findInIndex($pos,$subject,$predicate,$object,2);
	556	}else{
	557	break;
	558	}
	559
	560	case 3:
	561	if($subject!=NULL && $object != NULL){
	562	$pos=$subject->getLabel().$object->getLabel();
	563	return $this->_findInIndex($pos,$subject,$predicate,$object,3);
	564	}else{
	565	break;
	566	}
	567	case 0:
	568	if($subject!= null){
	569	$pos=$subject->getLabel();
	570	return $this->_findInIndex($pos,$subject,$predicate,$object,4);
	571	}
	572	if($predicate!= null){
	573	$pos=$predicate->getLabel();
	574	return $this->_findInIndex($pos,$subject,$predicate,$object,5);
	575	}
	576	if($object!= null){
	577	$pos=$object->getLabel();
	578	return $this->_findInIndex($pos,$subject,$predicate,$object,6);
	579	}
	580	}
	581	// if no index: linear search
	582	foreach($this->triples as $value) {
	583	if ($this->matchStatement($value, $subject, $predicate, $object))
	584	$res->add($value);
	585	}
	586	return $res;
	587
	588	}
	589
	590
	591
	592
	593
	594	/**
	595	* Method to search for triples using Perl-style regular expressions.
	596	* NULL input for any parameter will match anything.
	597	* Example: $result = $m->find_regex( NULL, NULL, $regex );
	598	* Finds all triples where the label of the object node matches the regular expression.
	599	* Returns an empty MemModel if nothing is found.
	600	*
	601	* @param string $subject_regex
	602	* @param string $predicate_regex
	603	* @param string $object_regex
	604	* @return object MemModel
	605	* @access public
	606	*/
	607	function findRegex($subject_regex, $predicate_regex, $object_regex) {
	608
	609	$res = new MemModel($this->getBaseURI());
	610
	611	if($this->size() == 0)
	612	return $res;
	613
	614	if($subject_regex == NULL && $predicate_regex == NULL && $object_regex == NULL)
	615	return $this;
	616
	617	foreach($this->triples as $value) {
	618	if (
	619	($subject_regex == NULL \|\| preg_match($subject_regex, $value->subj->getLabel())) &&
	620	($predicate_regex == NULL \|\| preg_match($predicate_regex, $value->pred->getLabel())) &&
	621	($object_regex == NULL \|\| preg_match($object_regex, $value->obj->getLabel()))
	622	) $res->add($value);
	623	}
	624
	625	return $res;
	626
	627	}
	628
	629	/**
	630	* Returns all tripels of a certain vocabulary.
	631	* $vocabulary is the namespace of the vocabulary inluding a # : / char at the end.
	632	* e.g. http://www.w3.org/2000/01/rdf-schema#
	633	* Returns an empty MemModel if nothing is found.
	634	*
	635	* @param string $vocabulary
	636	* @return object MemModel
	637	* @access public
	638	*/
	639	function findVocabulary($vocabulary) {
	640
	641	if($this->size() == 0)
	642	return new MemModel();
	643	if($vocabulary == NULL \|\| $vocabulary == '')
	644	return $this;
	645
	646	$res = new MemModel($this->getBaseURI());
	647	if($this->indexed==0){
	648	foreach($this->indexArr[5] as $key => $value){
	649	$pos=strpos($key,'#')+1;
	650	if(substr($key,0,$pos)==$vocabulary){
	651	for($i=1;$i<=$value[0];$i++){
	652	$res->add($this->triples[$value[$i]]);
	653	}
	654	}
	655	}
	656	return $res;
	657	}else{
	658	// Import Package Utility
	659	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_UTILITY);
	660	foreach($this->triples as $value) {
	661	if (RDFUtil::getNamespace($value->getPredicate()) == $vocabulary)
	662	$res->add($value);
	663	}
	664	return $res;
	665	}
	666	}
	667
	668	/**
	669	* Searches for triples and returns the first matching statement.
	670	* NULL input for any parameter will match anything.
	671	* Example: $result = $m->findFirstMatchingStatement( NULL, NULL, $node );
	672	* Returns the first statement of the MemModel where the object equals $node.
	673	* Returns an NULL if nothing is found.
	674	* You can define an offset to search for. Default = 0
	675	*
	676	* @param object Node $subject
	677	* @param object Node $predicate
	678	* @param object Node $object
	679	* @param integer $offset
	680	* @return object Statement
	681	* @access public
	682	*/
	683	function findFirstMatchingStatement($subject, $predicate, $object, $offset = 0) {
	684
	685	$currentOffset = 0;
	686	for($i=0;$i<=$offset;$i++)
	687	{
	688	$res = $this->findFirstMatchOff($subject, $predicate, $object, $currentOffset);
	689	$currentOffset=$res+1;
	690	}
	691	if ($res != -1) {
	692	return $this->triples[$res];
	693	} else {
	694	return NULL;
	695	}
	696	}
	697
	698
	699
	700
	701	/**
	702	* Searches for triples and returns the first matching statement from a given offset.
	703	* This method is used by the util/findIterator. NULL input for any parameter will match anything.
	704	* Example: $result = $m->findFirstMatchingStatement( NULL, NULL, $node, $off );
	705	* Returns the position of the first statement of the MemModel where the object equals $node from the given
	706	* offset.
	707	* Returns an -1 if nothing is found.
	708	*
	709	* @param object Node $subject
	710	* @param object Node $predicate
	711	* @param object Node $object
	712	* @param int $off
	713	* @return int
	714	* @access private
	715	*/
	716	function findFirstMatchOff($subject,$predicate, $object,$off) {
	717
	718	if (
	719	(!is_a($subject, 'Resource') && $subject != NULL) \|\|
	720	(!is_a($predicate, 'Resource') && $predicate != NULL) \|\|
	721	(!is_a($object, 'Node') && $object != NULL)
	722	) {
	723	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: find): Parameters must be subclasses of Node or NULL';
	724	trigger_error($errmsg, E_USER_ERROR);
	725	}
	726
	727	$match=-1;
	728	$ind=$this->indexed;
	729	if($subject == NULL && $predicate == NULL && $object == NULL)
	730	{
	731	foreach ($this->triples as $key => $statement)
	732	{
	733	if ($key >= $off)
	734	return $key;
	735	}
	736	return -1;
	737	}
	738
	739	switch($ind){
	740	case 1:
	741	if($subject!=NULL && $predicate != NULL && $object != NULL){
	742	$pos=$subject->getLabel().$predicate->getLabel().$object->getLabel();
	743	return $this->_findMatchIndex($pos,$subject,$predicate,$object,1,$off);
	744	}else{
	745	break;
	746	}
	747
	748	case 2:
	749	if($subject!=NULL && $predicate != NULL){
	750	$pos=$subject->getLabel().$predicate->getLabel();
	751	return $this->_findMatchIndex($pos,$subject,$predicate,$object,2,$off);
	752	}else{
	753	break;
	754	}
	755
	756	case 3:
	757	if($subject!=NULL && $object != NULL){
	758	$pos=$subject->getLabel().$object->getLabel();
	759	return $this->_findMatchIndex($pos,$subject,$predicate,$object,3,$off);
	760	}else{
	761	break;
	762	}
	763	case 0:
	764	if($subject!= null){
	765	$pos=$subject->getLabel();
	766	return $this->_findMatchIndex($pos,$subject,$predicate,$object,4,$off);
	767	}
	768	if($predicate!= null){
	769	$pos=$predicate->getLabel();
	770	return $this->_findMatchIndex($pos,$subject,$predicate,$object,5,$off);
	771	}
	772	if($object!= null){
	773	$pos=$object->getLabel();
	774	return $this->_findMatchIndex($pos,$subject,$predicate,$object,6,$off);
	775	}
	776	break;
	777	}
	778	// if no index: linear search
	779	foreach($this->triples as $key => $value){
	780	if ($this->matchStatement($value, $subject, $predicate, $object)){
	781	if($off<=$key){
	782	$match=$key;
	783	break;
	784	}
	785	}
	786	}
	787	return $match;
	788	}
	789
	790
	791	/**
	792	* Searches for triples and returns the number of matches.
	793	* NULL input for any parameter will match anything.
	794	* Example: $result = $m->findCount( NULL, NULL, $node );
	795	* Finds all triples with $node as object.
	796	*
	797	* @param object Node $subject
	798	* @param object Node $predicate
	799	* @param object Node $object
	800	* @return integer
	801	* @access public
	802	*/
	803	function findCount($subject, $predicate, $object) {
	804
	805	$res = $this->find($subject, $predicate, $object);
	806	return $res->size();
	807
	808	}
	809
	810
	811	/**
	812	* Perform an RDQL query on this MemModel.
	813	* This method returns an associative array of variable bindings.
	814	* The values of the query variables can either be RAP's objects (instances of Node)
	815	* if $returnNodes set to TRUE, or their string serialization.
	816	*
	817	* @access public
	818	* @param string $queryString
	819	* @param boolean $returnNodes
	820	* @return array [][?VARNAME] = object Node (if $returnNodes = TRUE)
	821	* OR array [][?VARNAME] = string
	822	*
	823	*/
	824	function rdqlQuery($queryString, $returnNodes = TRUE) {
	825
	826	// Import RDQL Package
	827	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_RDQL);
	828
	829	$parser = new RdqlParser();
	830	$parsedQuery =& $parser->parseQuery($queryString);
	831
	832	// this method can only query this MemModel
	833	// if another model was specified in the from clause throw an error
	834	if (isset($parsedQuery['sources'][1])) {
	835	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: rdqlQuery):';
	836	$errmsg .= ' this method can only query this MemModel';
	837	trigger_error($errmsg, E_USER_ERROR);
	838	}
	839
	840	$engine = new RdqlMemEngine();
	841	$res =& $engine->queryModel($this, $parsedQuery, $returnNodes);
	842
	843	return $res;
	844	}
	845
	846	/**
	847	* Perform an RDQL query on this MemModel.
	848	* This method returns an RdqlResultIterator of variable bindings.
	849	* The values of the query variables can either be RAP's objects (instances of Node)
	850	* if $returnNodes set to TRUE, or their string serialization.
	851	*
	852	* @access public
	853	* @param string $queryString
	854	* @param boolean $returnNodes
	855	* @return object RdqlResultIterator = with values as object Node (if $returnNodes = TRUE)
	856	* OR object RdqlResultIterator = with values as strings if (if $returnNodes = FALSE)
	857	*
	858	*/
	859	function rdqlQueryAsIterator($queryString, $returnNodes = TRUE) {
	860	// Import RDQL Package
	861	include_once(RDFAPI_INCLUDE_DIR.PACKAGE_RDQL);
	862	return new RdqlResultIterator($this->rdqlQuery($queryString, $returnNodes));
	863	}
	864
	865	/**
	866	* General method to replace nodes of a MemModel.
	867	* NULL input for any parameter will match nothing.
	868	* Example: $m->replace($node, NULL, $node, $replacement);
	869	* Replaces all $node objects beeing subject or object in
	870	* any triple of the MemModel with the $needle node.
	871	*
	872	* @param object Node $subject
	873	* @param object Node $predicate
	874	* @param object Node $object
	875	* @param object Node $replacement
	876	* @access public
	877	* @throws PhpError
	878	*/
	879	function replace($subject, $predicate, $object, $replacement) {
	880
	881	if (
	882	(!is_a($replacement, 'Node')) \|\|
	883	(!is_a($subject, 'Resource') && $subject != NULL) \|\|
	884	(!is_a($predicate, 'Resource') && $predicate != NULL) \|\|
	885	(!is_a($object, 'Node') && $object != NULL)
	886	) {
	887	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: replace): Parameters must be subclasses of Node or NULL';
	888	trigger_error($errmsg, E_USER_ERROR);
	889	}
	890
	891	if($this->size() == 0)
	892	break;
	893	foreach($this->triples as $key => $value) {
	894	if ($this->triples[$key]->subj->equals($subject)) {
	895	$this->triples[$key]->subj = $replacement;
	896	}
	897	if ($this->triples[$key]->pred->equals($predicate))
	898	$this->triples[$key]->pred = $replacement;
	899	if ($this->triples[$key]->obj->equals($object))
	900	$this->triples[$key]->obj = $replacement;
	901
	902	}
	903	$this->index($this->indexed);
	904	}
	905
	906
	907	/**
	908	* Internal method that checks, if a statement matches a S, P, O or NULL combination.
	909	* NULL input for any parameter will match anything.
	910	*
	911	* @param object Statement $statement
	912	* @param object Node $subject
	913	* @param object Node $predicate
	914	* @param object Node $object
	915	* @return boolean
	916	* @access private
	917	*/
	918	function matchStatement($statement, $subject, $predicate, $object) {
	919
	920	if(($subject != NULL) AND !($statement->subj->equals($subject)))
	921	return false;
	922
	923	if($predicate != NULL && !($statement->pred->equals($predicate)))
	924	return false;
	925
	926	if($object != NULL && !($statement->obj->equals($object)))
	927	return false;
	928
	929	return true;
	930	}
	931
	932
	933
	934
	935	/**
	936	* Checks if two models are equal.
	937	* Two models are equal if and only if the two RDF graphs they represent are isomorphic.
	938	*
	939	* @access public
	940	* @param object model &$that
	941	* @throws phpErrpr
	942	* @return boolean
	943	*/
	944
	945	function equals(&$that) {
	946
	947	if (!is_a($that, 'Model')) {
	948	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: equals): Model expected.';
	949	trigger_error($errmsg, E_USER_ERROR);
	950	}
	951
	952	if ($this->size() != $that->size())
	953	return FALSE;
	954	/*
	955	if (!$this->containsAll($that))
	956	return FALSE;
	957	return TRUE;
	958	*/
	959	include_once(RDFAPI_INCLUDE_DIR. "util/ModelComparator.php");
	960	return ModelComparator::compare($this,$that);
	961	}
	962
	963	/**
	964	* Returns a new MemModel that is the set-union of the MemModel with another model.
	965	* Duplicate statements are removed. If you want to allow duplicates, use addModel() which is much faster.
	966	*
	967	* The result of taking the set-union of two or more RDF graphs (i.e. sets of triples)
	968	* is another graph, which we will call the merge of the graphs.
	969	* Each of the original graphs is a subgraph of the merged graph. Notice that when forming
	970	* a merged graph, two occurrences of a given uriref or literal as nodes in two different
	971	* graphs become a single node in the union graph (since by definition they are the same
	972	* uriref or literal) but blank nodes are not 'merged' in this way; and arcs are of course
	973	* never merged. In particular, this means that every blank node in a merged graph can be
	974	* identified as coming from one particular graph in the original set of graphs.
	975	*
	976	* Notice that one does not, in general, obtain the merge of a set of graphs by concatenating
	977	* their corresponding N-triples documents and constructing the graph described by the merged
	978	* document, since if some of the documents use the same node identifiers, the merged document
	979	* will describe a graph in which some of the blank nodes have been 'accidentally' merged.
	980	* To merge Ntriples documents it is necessary to check if the same nodeID is used in two or
	981	* more documents, and to replace it with a distinct nodeID in each of them, before merging the
	982	* documents. (Not implemented yet !!!!!!!!!!!)
	983	*
	984	* @param object Model $model
	985	* @return object MemModel
	986	* @access public
	987	* @throws phpErrpr
	988	*
	989	*/
	990	function & unite(&$model) {
	991
	992	if (!is_a($model, 'Model')) {
	993	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: unite): Model expected.';
	994	trigger_error($errmsg, E_USER_ERROR);
	995	}
	996
	997	$res = $this;
	998
	999	if (is_a($model, 'MemModel')) {
	1000	require_once RDFAPI_INCLUDE_DIR . 'util/StatementIterator.php';
	1001	$stateIt=new StatementIterator($model);
	1002	while($statement=$stateIt->next())
	1003	{
	1004	$res->addWithoutDuplicates($statement);
	1005	}
	1006	}
	1007
	1008	elseif (is_a($model, 'DbModel')) {
	1009	$memModel =& $model->getMemModel();
	1010	foreach($memModel->triples as $value)
	1011	$res->addWithoutDuplicates($value);
	1012	}
	1013
	1014	return $res;
	1015	}
	1016
	1017	/**
	1018	* Returns a new MemModel that is the subtraction of another model from this MemModel.
	1019	*
	1020	* @param object Model $model
	1021	* @return object MemModel
	1022	* @access public
	1023	* @throws phpErrpr
	1024	*/
	1025
	1026	function & subtract(&$model) {
	1027
	1028	if (!is_a($model, 'Model')) {
	1029	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: subtract): Model expected.';
	1030	trigger_error($errmsg, E_USER_ERROR);
	1031	}
	1032
	1033	$res = $this;
	1034
	1035
	1036	if (is_a($model, 'MemModel'))
	1037	{
	1038	require_once RDFAPI_INCLUDE_DIR . 'util/StatementIterator.php';
	1039	$stateIt=new StatementIterator($model);
	1040	while($statement=$stateIt->next())
	1041	{
	1042	$res->remove($statement);
	1043	}
	1044	}
	1045	elseif (is_a($model, 'DbModel'))
	1046	{
	1047	$memModel =& $model->getMemModel();
	1048	foreach($memModel->triples as $value)
	1049	$res->remove($value);
	1050	}
	1051
	1052
	1053	return $res;
	1054	}
	1055
	1056	/**
	1057	* Returns a new MemModel containing all the statements which are in both this MemModel and another.
	1058	*
	1059	* @param object Model $model
	1060	* @return object MemModel
	1061	* @access public
	1062	* @throws phpErrpr
	1063	*/
	1064	function & intersect(&$model) {
	1065
	1066	if (!is_a($model, 'Model')) {
	1067	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: intersect: Model expected.';
	1068	trigger_error($errmsg, E_USER_ERROR);
	1069	}
	1070
	1071	$res = new MemModel($this->getBaseURI());
	1072
	1073	if (is_a($model, 'DbModel') \|\| is_a($model, 'RDFSBModel'))
	1074	{
	1075	$memModel =& $model->getMemModel();
	1076	foreach($memModel->triples as $value) {
	1077	if ($this->contains($value))
	1078	$res->add($value);
	1079	}
	1080	}
	1081
	1082	elseif (is_a($model, 'MemModel'))
	1083	{
	1084	foreach($model->triples as $value) {
	1085	if ($this->contains($value))
	1086	$res->add($value);
	1087	}
	1088	}
	1089
	1090
	1091
	1092	return $res;
	1093	}
	1094
	1095
	1096	/**
	1097	* Adds another model to this MemModel.
	1098	* Duplicate statements are not removed.
	1099	* If you don't want duplicates, use unite().
	1100	* If any statement of the model to be added to this model contains a blankNode
	1101	* with an identifier already existing in this model, a new blankNode is generated.
	1102	*
	1103	* @param object Model $model
	1104	* @access public
	1105	* @throws phpErrpr
	1106	*
	1107	*/
	1108	function addModel(&$model) {
	1109
	1110	if (!is_a($model, 'Model')) {
	1111	$errmsg = RDFAPI_ERROR . '(class: MemModel; method: addModel): Model expected.';
	1112	trigger_error($errmsg, E_USER_ERROR);
	1113	}
	1114
	1115	$blankNodes_tmp = array();
	1116
	1117	if (is_a($model, 'MemModel')) {
	1118	require_once RDFAPI_INCLUDE_DIR . 'util/StatementIterator.php';
	1119	$stateIt=new StatementIterator($model);
	1120	while($statement=$stateIt->next())
	1121	{
	1122	$this->_addStatementFromAnotherModel($statement, $blankNodes_tmp);
	1123	};
	1124	$this->addParsedNamespaces($model->getParsedNamespaces());
	1125	}
	1126
	1127	elseif (is_a($model, 'DbModel')) {
	1128	$memModel =& $model->getMemModel();
	1129	foreach($memModel->triples as $value)
	1130	$this->_addStatementFromAnotherModel($value, $blankNodes_tmp);
	1131	}
	1132	$this->index($this->indexed);
	1133	}
	1134
	1135
	1136	/**
	1137	* Reifies the MemModel.
	1138	* Returns a new MemModel that contains the reifications of all statements of this MemModel.
	1139	*
	1140	* @access public
	1141	* @return object MemModel
	1142	*/
	1143	function & reify() {
	1144	$res = new MemModel($this->getBaseURI());
	1145
	1146	$stateIt=$this->getStatementIterator();
	1147	while($statement=$stateIt->next())
	1148	{
	1149	$pointer =& $statement->reify($res);
	1150	$res->addModel($pointer);
	1151	};
	1152
	1153	return $res;
	1154	}
	1155
	1156	/**
	1157	* Returns a StatementIterator for traversing the MemModel.
	1158	* @access public
	1159	* @return object StatementIterator
	1160	*/
	1161	function & getStatementIterator() {
	1162	// Import Package Utility
	1163	require_once RDFAPI_INCLUDE_DIR . 'util/StatementIterator.php';
	1164
	1165	$si = new StatementIterator($this);
	1166	return $si;
	1167	}
	1168
	1169	/**
	1170	* Returns a FindIterator for traversing the MemModel.
	1171	* @access public
	1172	* @return object FindIterator
	1173	*/
	1174	function & findAsIterator($sub=null,$pred=null,$obj=null) {
	1175	// Import Package Utility
	1176	require_once RDFAPI_INCLUDE_DIR . 'util/FindIterator.php';
	1177
	1178	$if = new FindIterator($this,$sub,$pred,$obj);
	1179	return $if;
	1180	}
	1181
	1182	/**
	1183	* Returns a FindIterator for traversing the MemModel.
	1184	* @access public
	1185	* @return object FindIterator
	1186	*/
	1187	function & iterFind($sub=null,$pred=null,$obj=null) {
	1188	// Import Package Utility
	1189	require_once RDFAPI_INCLUDE_DIR . 'util/IterFind.php';
	1190
	1191	$if = new IterFind($this,$sub,$pred,$obj);
	1192	return $if;
	1193	}
	1194
	1195
	1196	/**
	1197	* Returns the models namespaces.
	1198	*
	1199	* @author Tobias Gauï¿œ<tobias.gauss@web.de>
	1200	* @access public
	1201	* @return Array
	1202	*/
	1203	function getParsedNamespaces(){
	1204	if(count($this->parsedNamespaces)!=0){
	1205	return $this->parsedNamespaces;
	1206	}else{
	1207	return false;
	1208	}
	1209	}
	1210
	1211
	1212
	1213	/**
	1214	* Adds the namespaces to the model. This method is called by
	1215	* the parser. !!!! addParsedNamespaces() not overwrites manual
	1216	* added namespaces in the model !!!!
	1217	*
	1218	* @author Tobias Gauï¿œ<tobias.gauss@web.de>
	1219	* @access public
	1220	* @param Array $newNs
	1221	*/
	1222	function addParsedNamespaces($newNs){
	1223	if($newNs)
	1224	$this->parsedNamespaces = $this->parsedNamespaces + $newNs;
	1225	}
	1226
	1227
	1228	/**
	1229	* Adds a namespace and prefix to the model.
	1230	*
	1231	* @author Tobias Gauï¿œ<tobias.gauss@web.de>
	1232	* @access public
	1233	* @param String
	1234	* @param String
	1235	*/
	1236	function addNamespace($prefix, $nmsp){
	1237	$this->parsedNamespaces[$nmsp]=$prefix;
	1238	}
	1239
	1240	/**
	1241	* removes a single namespace from the model
	1242	*
	1243	* @author Tobias Gauï¿œ<tobias.gauss@web.de>
	1244	* @access public
	1245	* @param String $nmsp
	1246	*/
	1247	function removeNamespace($nmsp){
	1248	if(isset($this->parsedNamespaces[$nmsp])){
	1249	unset($this->parsedNamespaces[$nmsp]);
	1250	return true;
	1251	}else{
	1252	return false;
	1253	}
	1254	}
	1255
	1256
	1257
	1258	/**
	1259	* Close the MemModel and free up resources held.
	1260	*
	1261	* @access public
	1262	*/
	1263	function close() {
	1264	unset( $this->baseURI );
	1265	unset( $this->triples );
	1266	}
	1267
	1268	// =============================================================================
	1269	// ************************* helper functions ******************************
	1270	// =============================================================================
	1271	/**
	1272	* Checks if $statement is in index
	1273	*
	1274	* @param int $ind
	1275	* @param Statement &$statement
	1276	* @return boolean
	1277	* @access private
	1278	*/
	1279	function _containsIndex(&$statement,$ind){
	1280	switch($ind){
	1281	case 4:
	1282	$sub=$statement->getSubject();
	1283	$pos=$sub->getLabel();
	1284	break;
	1285	case 1:
	1286	$sub=$statement->getSubject();
	1287	$pred=$statement->getPredicate();
	1288	$obj=$statement->getObject();
	1289	$pos=$sub->getLabel().$pred->getLabel().$obj->getLabel();
	1290	break;
	1291	case 2:
	1292	$sub=$statement->getSubject();
	1293	$pred=$statement->getPredicate();
	1294	$pos=$sub->getLabel().$pred->getLabel();
	1295	break;
	1296	case 3:
	1297	$sub=$statement->getSubject();
	1298	$obj=$statement->getObject();
	1299	$pos=$sub->getLabel().$obj->getLabel();
	1300	break;
	1301	}
	1302
	1303	if (!isset($this->indexArr[$ind][$pos]))
	1304	return FALSE;
	1305	foreach ($this->indexArr[$ind][$pos] as $key => $value) {
	1306	$t=$this->triples[$value];
	1307	if ($t->equals($statement))
	1308	return TRUE;
	1309	}
	1310	return FALSE;
	1311	}
	1312
	1313
	1314
	1315
	1316
	1317	/**
	1318	* finds a statement in an index. $pos is the Position in the index
	1319	* and $ind the adequate searchindex
	1320	*
	1321	* @param String $pos
	1322	* @param Object Subject &$subject
	1323	* @param Object Predicate &$predicate
	1324	* @param Object Object &$object
	1325	* @param int &ind
	1326	* @return MemModel $res
	1327	* @access private
	1328	*/
	1329	function _findInIndex($pos,&$subject,&$predicate,&$object,$ind){
	1330	$res = new MemModel($this->getBaseURI());
	1331	$res->indexed=-1;
	1332	if (!isset($this->indexArr[$ind][$pos]))
	1333	return $res;
	1334	foreach($this->indexArr[$ind][$pos] as $key =>$value){
	1335	$t=$this->triples[$value];
	1336	if ($this->matchStatement($t,$subject,$predicate,$object))
	1337	$res->add($t);
	1338	}
	1339	return $res;
	1340	}
	1341	/**
	1342	* adds/removes a statement into/from an index.
	1343	* mode=0 removes the statement from the index;
	1344	* mode=1 adds the statement into the index.
	1345	* returns the statements position.
	1346	*
	1347	* @param Object Statement &$statement
	1348	* @param int $k
	1349	* @param int $ind
	1350	* @param int $mode
	1351	* @return int $k
	1352	* @access private
	1353	*/
	1354	function _indexOpr(&$statement,$k,$ind,$mode){
	1355	// determine position in adequate index
	1356	switch($ind){
	1357	case 1:
	1358	$s=$statement->getSubject();
	1359	$p=$statement->getPredicate();
	1360	$o=$statement->getObject();
	1361	$pos=$s->getLabel().$p->getLabel().$o->getLabel();
	1362	break;
	1363	case 2:
	1364	$s=$statement->getSubject();
	1365	$p=$statement->getPredicate();
	1366	$pos=$s->getLabel().$p->getLabel();
	1367	break;
	1368	case 3:
	1369	$s=$statement->getSubject();
	1370	$o=$statement->getObject();
	1371	$pos=$s->getLabel().$o->getLabel();
	1372	break;
	1373	case 4:
	1374	$s=$statement->getSubject();
	1375	$pos=$s->getLabel();
	1376	break;
	1377	case 5:
	1378	$p=$statement->getPredicate();
	1379	$pos=$p->getLabel();
	1380	break;
	1381	case 6:
	1382	$o=$statement->getObject();
	1383	$pos=$o->getLabel();
	1384	break;
	1385	}
	1386	switch($mode){
	1387	// add in Index
	1388	case 1:
	1389	if(isset($this->indexArr[$ind][$pos])){
	1390	$this->indexArr[$ind][$pos][] = $k;
	1391	}else{
	1392	$this->indexArr[$ind][$pos][0] = $k;
	1393	}
	1394	break;
	1395	// remove from Index
	1396	case 0:
	1397	$subject=$statement->getSubject();
	1398	$predicate=$statement->getPredicate();
	1399	$object=$statement->getObject();
	1400	$k=-1;
	1401	if(!isset($this->indexArr[$ind][$pos])){
	1402	return -1;
	1403	}
	1404	$num=count($this->indexArr[$ind][$pos]);
	1405	foreach($this->indexArr[$ind][$pos] as $key => $value){
	1406	$t=$this->triples[$value];
	1407	if($this->matchStatement($t,$subject,$predicate,$object)){
	1408	$k=$value;
	1409	if($num==1){
	1410	unset($this->indexArr[$ind][$pos]);
	1411	}else{
	1412	unset($this->indexArr[$ind][$pos][$key]);
	1413	}
	1414	return $k;
	1415	}
	1416	}
	1417	break;
	1418	}
	1419	return $k;
	1420	}
	1421
	1422
	1423	/**
	1424	* finds next or previous matching statement.
	1425	* Returns Position in model or -1 if there is no match.
	1426	*
	1427	*
	1428	* @param String
	1429	* @param object Subject
	1430	* @param object Predicate
	1431	* @param object Object
	1432	* @param integer
	1433	* @param integer
	1434	* @return integer
	1435	* @access private
	1436	*/
	1437	function _findMatchIndex($pos,&$s,&$p,&$o,$ind,$off){
	1438	$match=-1;
	1439	if (!isset($this->indexArr[$ind][$pos])) {
	1440	return $match;}
	1441	foreach($this->indexArr[$ind][$pos] as $key =>$value){
	1442	$t=$this->triples[$value];
	1443	if ($this->matchStatement($t,$s,$p,$o)){
	1444	if($off <= $value){
	1445	$match= $value;
	1446	return $match;
	1447	}
	1448	}
	1449	}
	1450
	1451	return $match;
	1452
	1453	}
	1454
	1455
	1456
	1457
	1458	} // end: MemModel
	1459
	1460
	1461	?>

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

Download in other formats: