source: pmb4.2/trunk/fuentes/pmb/classes/onto/onto_ontology.class.php @ 815

Last change on this file since 815 was 815, checked in by jrpelegrina, 4 years ago

Initial release of pmb 4.2

  • Property svn:executable set to *
File size: 14.0 KB
Line 
1<?php
2// +-------------------------------------------------+
3// | 2002-2007 PMB Services / www.sigb.net pmb@sigb.net et contributeurs (voir www.sigb.net)
4// +-------------------------------------------------+
5// $Id: onto_ontology.class.php,v 1.25 2014-09-17 10:41:18 arenou Exp $
6
7if (stristr($_SERVER['REQUEST_URI'], ".class.php")) die("no access");
8
9
10require_once($class_path."/onto/onto_store.class.php");
11require_once($class_path."/onto/common/onto_common_class.class.php");
12require_once($class_path."/onto/common/onto_common_property.class.php");
13require_once($class_path."/onto/onto_class.class.php");
14require_once($class_path."/onto/onto_property.class.php");
15
16
17/**
18 * class onto_ontology
19 *
20 */
21class onto_ontology {
22
23        /** Aggregations: */
24
25        /** Compositions: */
26
27         /*** Attributes: ***/
28
29        /**
30         * Tableau des URI & infos annexes des classes
31         * @access protected
32         */
33        protected $classes_uris;
34
35        /**
36         * Tableau des instances des classes déjà  lues
37         * @access private
38         */
39        private $classes;
40
41        /**
42         * Tableau des URI & infos annexes (domaine, range) des propriétés de l'ontologie
43         * @access private
44         */
45        private $properties_uri;
46       
47        /**
48         * Tableau des instances des propriétés déjà  lues
49         * @access private
50         */
51        private $properties;
52
53        /**
54         * nom de l'ontologie (pmb:name)
55         * @access public
56         */
57        public $name = "";
58
59        /**
60         * Store de l'ontologie
61         * @var onto_store
62         * @access private
63         */
64        private $store;
65       
66        /**
67         * Tableau des URI des propriétés inverse
68         * @access private
69         */
70        private $inverse_of;
71       
72        /**
73         *
74         *
75         * @param onto_store store
76
77         * @return void
78         * @access public
79         */
80        public function __construct( $store ) {
81                $this->store = $store;
82                $this->get_name();
83                $this->get_classes();
84                $this->get_properties();
85                $this->get_inverse_of_properties();
86        } // end of member function __construct
87
88        /**
89         * Récupère le nom informatique de l'ontologie
90         *
91         * @return void
92         * @access private
93         */     
94        private function get_name(){
95                $query = "select ?name ?title where {
96                        ?onto rdf:type <http://www.w3.org/2002/07/owl#Ontology> .
97                        ?onto pmb:name ?name .
98                        optional {             
99                                ?onto dct:title ?title
100                        }
101                }";
102                if($this->store->query($query)){
103                        if($this->store->num_rows()){
104                                $result = $this->store->get_result();
105                                $this->name = $result[0]->name;
106                                $this->title = $result[0]->title;
107                        }
108                }else{
109                        highlight_string(print_r($this->store->get_errors(),true));
110                }
111        }
112       
113        /**
114         * Récupère la liste des URI des classes de l'ontologie (propriété classes_uri)
115         *
116         * @return void
117         * @access public
118         */
119        public function get_classes( ) {
120                $query  = "select * where {
121                        ?class rdf:type <http://www.w3.org/2002/07/owl#Class> .
122                        ?class rdfs:label ?label .
123                        ?class pmb:name ?name
124                }";
125                if($this->store->query($query)){
126                        if($this->store->num_rows()){
127                                $result = $this->store->get_result();
128                                foreach ($result as $elem){
129                                        $class = new onto_class();
130                                        $class->uri = $elem->class;
131                                        $class->name = $elem->label;
132                                        $class->pmb_name = $elem->name;
133                                        $this->classes_uris[$elem->class] = $class;                                     
134                                }
135                        }
136                }else{
137                        highlight_string(print_r($this->store->get_errors(),true));
138                }
139                return $this->classes;
140               
141        } // end of member function get_classes
142
143        /**
144         * Retourne une instance de la classe correspondante à l'URI
145         *
146         * @param string uri_class
147
148         * @return onto_common_class
149         * @access public
150         */
151        public function get_class( $uri_class ) {
152                if(!$this->classes[$uri_class]){
153                        $elements = array(
154                                'class_uri' => $uri_class
155                        );
156                        $class_name = $this->get_class_name("class", $elements);
157                        $this->classes[$uri_class] = new $class_name($uri_class,$this);
158                        $this->classes[$uri_class]->set_pmb_name($this->classes_uris[$uri_class]->pmb_name);
159                        $this->classes[$uri_class]->set_onto_name($this->name);
160                }
161                return $this->classes[$uri_class];             
162        } // end of member function get_class
163
164        /**
165         * Récupère les cardinalités entre une classe et une propriété
166         *
167         * @param string uri_class
168
169         * @param string uri_property
170
171         * @return onto_restriction
172         * @access public
173         */
174        public function get_restriction($uri_class,$uri_property) {
175                $restriction = new onto_restriction();
176                //recherche des exlusions !
177                $query = "select ?distinct where {
178                        <".$uri_property."> pmb:distinctWith ?distinct
179                }";
180                if($this->store->query($query)){
181                        if($this->store->num_rows()){
182                                $results = $this->store->get_result();
183                                foreach ($results as $result){
184                                        $restriction->set_new_distinct($this->get_property($uri_class, $result->distinct));
185                                }
186                        }
187                }else{
188                        var_dump($this->store->get_errors());
189                }
190                $query = "select ?max ?min where {
191                        <".$uri_class."> rdf:type <http://www.w3.org/2002/07/owl#Class> .
192                        <".$uri_class."> rdfs:subClassOf ?restrict .   
193                        ?restrict rdf:type <http://www.w3.org/2002/07/owl#Restriction> .
194                        ?restrict owl:onProperty <".$uri_property."> .         
195                        optional {
196                                ?restrict owl:maxCardinality ?max
197                        } .
198                        optional {
199                                ?restrict owl:minCardinality ?min
200                        }
201                }";
202                if($this->store->query($query)){
203                        if($this->store->num_rows()){
204                                $results = $this->store->get_result();
205                                foreach ($results as $result){
206                                        if($result->min){
207                                                $restriction->set_min($result->min);
208                                        }
209                                        if($result->max){
210                                                $restriction->set_max($result->max);
211                                        }
212                                }
213                        }
214                }else{
215                        var_dump($this->store->get_errors());
216                }
217                return $restriction;
218        } // end of member function get_card
219
220        /**
221         * Retourne la liste des URI des propriétés avec les domain et range (propriété
222         * properties_uri)
223         *
224         * @return void
225         * @access public
226         */
227        public function get_properties( ) {
228                if (!$this->properties_uri) {
229                        $query  = "select * where {
230                                ?property rdf:type <http://www.w3.org/1999/02/22-rdf-syntax-ns#Property> .
231                                ?property rdfs:label ?label .
232                                ?property pmb:name ?name .
233                                optional {
234                                        ?property rdfs:range ?range
235                                } .
236                                optional {
237                                        ?property rdfs:domain ?domain
238                                }
239                                optional {
240                                        ?property pmb:datatype ?datatype
241                                } .
242                                optional {
243                                        ?property pmb:defaultValueType ?default_value .
244                                        ?property pmb:defaultValue ?default_value_name
245                                } .
246                                optional {
247                                        ?property pmb:flag ?flag                               
248                                }
249                        }";
250                        if($this->store->query($query)){
251                                if($this->store->num_rows()){
252                                        $result = $this->store->get_result();
253                                        foreach ($result as $elem){
254                                                if(!isset($this->properties_uri[$elem->property])){
255                                                        $this->properties_uri[$elem->property] = new onto_property();
256                                                        $this->properties_uri[$elem->property]->uri = $elem->property;
257                                                        $this->properties_uri[$elem->property]->name = $elem->label;
258                                                        $this->properties_uri[$elem->property]->pmb_name = $elem->name;
259                                                        $this->properties_uri[$elem->property]->pmb_datatype = $elem->datatype;
260                                                }
261                                                if($elem->domain){
262                                                        $this->properties_uri[$elem->property]->domain[] = $elem->domain;
263                                                }
264                                                if($elem->range){
265                                                        if(!$this->properties_uri[$elem->property]->range) {
266                                                                $this->properties_uri[$elem->property]->range = array();
267                                                        }
268                                                        //il faut gérer le cas du noeud blanc
269                                                        if($elem->range_type == "bnode"){
270                                                                $this->properties_uri[$elem->property]->range = array_merge($this->properties_uri[$elem->property]->range,$this->get_recursive_blank_range($elem->range));
271                                                        }else{
272                                                                if(!in_array($elem->range,$this->properties_uri[$elem->property]->range)){
273                                                                        $this->properties_uri[$elem->property]->range[] = $elem->range;
274                                                                }
275                                                        }
276                                                }
277                                                if($elem->default_value){
278                                                        $this->properties_uri[$elem->property]->default_value = array(
279                                                                'value' => $elem->default_value_name,
280                                                                'type' => $elem->default_value
281                                                        );
282                                                }
283                                                if($elem->flag){
284                                                        if(!$this->properties_uri[$elem->property]->flags) {
285                                                                $this->properties_uri[$elem->property]->flags = array();
286                                                        }
287                                                        $this->properties_uri[$elem->property]->flags[] = $elem->flag;
288                                                }
289                                        }
290                                }
291                                //on vérifie, si aucun domaine précisé, on peut mettre la propriété partout
292                                foreach($this->properties_uri as $property_uri => $property){
293                                        if(!count($property->domain)){
294                                                foreach($this->classes_uris as $class_uri => $class){
295                                                        $this->properties_uri[$property_uri]->domain[] = $class_uri;
296                                                }
297                                        }
298                                }
299                        }else{
300                                highlight_string(print_r($this->store->get_errors(),true));
301                        }
302                }
303                return $this->properties_uri;
304        } // end of member function get_properties
305
306       
307        protected function get_recursive_blank_range($brange){
308                $range = array();
309                $query = "select * where {
310                        <".$brange."> ?prop ?value .
311                }";
312                $this->store->query($query);
313                $range_results = $this->store->get_result();
314                foreach($range_results as $range_result){
315                        switch($range_result->prop){
316                                case "http://www.w3.org/2002/07/owl#unionOf" :
317                                        $range = array_merge($range,$this->get_recursive_blank_range($range_result->value));
318                                        break;
319                                case "http://www.w3.org/1999/02/22-rdf-syntax-ns#first":
320                                        $range[] = $range_result->value;
321                                        break;
322                                case "http://www.w3.org/1999/02/22-rdf-syntax-ns#rest" :
323                                        if($range_result->value_type == "bnode"){
324                                                $range = array_merge($range,$this->get_recursive_blank_range($range_result->value));
325                                        }else if ($range_result->value != "http://www.w3.org/1999/02/22-rdf-syntax-ns#nil"){
326                                                $range[] = $range_result->value; 
327                                        }
328                                        break;
329                        }
330                }
331                return $range;
332        }
333       
334        public function get_class_properties($class_uri){
335                $properties = array();
336                foreach($this->properties_uri as $property_uri => $property){
337                        if(in_array($class_uri,$property->domain)){
338                                $properties[] = $property_uri;
339                        }
340                }
341                return $properties;
342        }
343        /**
344         *
345         *
346         * @param string uri_property
347
348         * @return onto_common_property
349         * @access public
350         */
351        public function get_property($uri_class, $uri_property ) {
352                if(!$this->properties[$uri_property][$uri_class]){
353                        $elements = array(
354                                        'class_uri' => $uri_class,
355                                        'property_uri' => $uri_property
356                        );
357                        $class_name = $this->get_class_name("property", $elements);
358                        $this->properties[$uri_property][$uri_class] = new $class_name($uri_property,$this);
359                        $this->properties[$uri_property][$uri_class]->set_domain($this->properties_uri[$uri_property]->domain);
360                        $this->properties[$uri_property][$uri_class]->set_range($this->properties_uri[$uri_property]->range);
361                        $this->properties[$uri_property][$uri_class]->set_pmb_name($this->properties_uri[$uri_property]->pmb_name);
362                        if($this->inverse_of[$uri_property]){
363                                $this->properties[$uri_property][$uri_class]->set_inverse_of($this->get_property($uri_class,$this->inverse_of[$uri_property]));
364                        }
365                        $this->properties[$uri_property][$uri_class]->set_onto_name($this->name);
366                }
367                return $this->properties[$uri_property][$uri_class];
368               
369        } // end of member function get_property
370
371        /**
372         *
373         *
374         * @param string class_prefix
375
376         * @param Array() elements Tableau des noms pour déterminer le nom de la classe. Associatif ?
377
378         * @return string
379         * @access public
380         */
381        public function get_class_name( $class_prefix,  $elements ) {
382                return $this->search_class_name($class_prefix, $this->name, $elements);
383        } // end of member function get_class_name
384
385        protected function search_class_name($class_prefix,$name,$elements){
386                switch ($class_prefix){
387                        case "class" :
388                                /*
389                                 * $elements['class_uri'] => URI de la classe
390                                 */
391                                //ex : onto_skos_class_concept
392                                $class_name = "onto_".$name."_".$class_prefix."_".$this->classes_uris[$elements['class_uri']]->pmb_name;
393                                if(!class_exists($class_name)){
394                                        //ex : onto_skos_class
395                                        $class_name = "onto_".$name."_".$class_prefix;
396                                        if(!class_exists($class_name)){
397                                                $class_name = $this->search_class_name($class_prefix,"common",$elements);
398                                        }
399                                }
400                                break;
401                        case "property" :
402                                /*
403                                 * $elements['class_uri'] => URI de la classe
404                                 * $elements['property_uri'] => URI de la classe
405                                 */
406                                //ex : onto_skos_class_concept_property_inscheme
407                                $class_name = "onto_".$name."_class_".$this->classes_uris[$elements['class_uri']]->pmb_name."_".$class_prefix."_".$this->properties_uri[$elements['property_uri']]->pmb_name;
408                                if(!class_exists($class_name)){
409                                        //ex : onto_skos_property_inscheme
410                                        $class_name = "onto_".$name."_".$class_prefix."_".$this->properties_uri[$elements['property_uri']]->pmb_name;
411                                        if(!class_exists($class_name)){
412                                                //ex : onto_skos_property
413                                                $class_name = "onto_".$name."_".$class_prefix;
414                                                if(!class_exists($class_name)){
415                                                        $class_name = $this->search_class_name($class_prefix, "common", $elements);
416                                                }
417                                        }
418                                }
419                                break;
420                }
421                return $class_name;
422        }
423       
424        public function get_label($object){
425                global $msg,$lang;
426                if(!$this->name){
427                        $this->get_name();
428                }
429
430                if(isset($msg['onto_'.$this->name.'_'.$object->pmb_name])){
431                        //le message PMB spécifique pour l'ontologie courante
432                        $label = $msg['onto_'.$this->name.'_'.$object->pmb_name];
433                }else if (isset($msg['onto_common_'.$object->pmb_name])){
434                        //le message PMB générique
435                        $label = $msg['onto_common_'.$object->pmb_name];
436                }else {
437                        $label = $object->name;
438                }
439                return $label;
440        }
441
442        public function get_class_label($uri_class){
443                return $this->get_label($this->classes_uris[$uri_class]);
444        }
445       
446        public function get_property_label($uri_property){
447                return $this->get_label($this->properties_uri[$uri_property]);
448        }
449       
450        public function get_property_pmb_datatype($uri_property){
451                return $this->properties_uri[$uri_property]->pmb_datatype;
452        }
453       
454        public function get_property_default_value($uri_property){
455                return $this->properties_uri[$uri_property]->default_value;
456        }
457       
458        public function get_classes_uri(){
459                return $this->classes_uris;
460        }
461       
462        public function get_inverse_of_properties(){
463                if(!count($this->inverse_of)){
464                        $query = "select * {
465                                ?property owl:inverseOf ?inverse
466                        }";
467                        $this->store->query($query);
468                        $inverse_results = $this->store->get_result();
469                        foreach($inverse_results as $inverse_of){
470                                $this->inverse_of[$inverse_of->property] = $inverse_of->inverse;
471                        }
472                }
473                return $this->inverse_of;
474        }
475       
476        public function get_flags($uri_class="",$uri_property=""){
477                $flags = array();
478                if($class_uri && isset($this->classes_uri[$uri_class]->flags)){
479                        $flags = $this->classes_uri[$uri_class]->flags;
480                }else if (isset($this->properties_uri[$uri_property]->flags)){
481                        $flags = $this->properties_uri[$uri_property]->flags;
482                }
483                return $flags;
484        }
485} // end of onto_ontology
Note: See TracBrowser for help on using the repository browser.