Changeset 414

Show
Ignore:
Timestamp:
05/04/09 13:37:14 (9 years ago)
Author:
samuraraujo
Message:
 
Files:
1 modified

Legend:

Unmodified
Added
Removed
  • Explorator/trunk/vendor/plugins/active_rdf/lib/active_rdf/objectmanager/resource.rb

    r409 r414  
     1require "uri" 
    12require 'active_rdf' 
    23require 'objectmanager/object_manager' 
     
    1920      attr_accessor :class_uri 
    2021      def reset_cache()                
    21         $triple = Hash.new  
    22         $all_predicates_array = Array.new         
    23         RDFS::Resource.find_all_predicates() 
    24          
    25       end 
    26     end 
    27      
     22        Thread.current[:triples].clear         
     23      end 
     24    end     
    2825    # uri of the resource (for instances of this class: rdf resources) 
    2926    attr_reader :uri 
    30     $triple 
     27    
    3128    # creates new resource representing an RDF resource 
    3229    def initialize uri       
     
    4340      else  
    4441        raise ActiveRdfError, "cannot create resource <#{uri}>" 
    45       end       
    46       $all_predicates_array = Array.new    if         $all_predicates_array ==nil     
    47       $triple = Hash.new if $triple == nil 
     42      end            
     43      Thread.current[:triples]=Hash.new if Thread.current[:triples]== nil  
    4844      @predicates = Hash.new 
    4945    end 
     
    199195      end 
    200196    end 
    201     def self.find_all_predicates   
    202       puts '############ FINDING PREDICATES #############' 
    203       $all_predicates_array = Query.new.distinct(:s).where(:s,Namespace.lookup(:rdf,:type),Namespace.lookup(:rdf,:Property)).execute if $all_predicates_array == nil 
     197     
     198    def load 
     199      Query.new.distinct(:p,:o).where(self, :p,:o).execute 
    204200    end 
    205201    def localname       
     
    209205    # manages invocations such as eyal.age 
    210206    def method_missing(method, *args) 
    211        # possibilities: 
     207        
     208      # possibilities: 
    212209      # 1. eyal.age is a property of eyal (triple exists <eyal> <age> "30") 
    213210      # evidence: eyal age ?a, ?a is not nil (only if value exists) 
     
    296293        return namespace 
    297294      end 
    298  
    299   
    300       $all_predicates_array.each do |pred| 
    301          
     295      all_instance_predicates.each do |pred|         
    302296        if Namespace.localname(pred) == methodname 
    303297  
     
    305299            return set_predicate(pred, args) 
    306300          else  
    307                 value =  get_predicate(pred, flatten) 
    308                          
     301            value =  get_predicate(pred, flatten)                         
    309302            return value if value != nil 
    310303          end 
    311304        end 
    312305    end 
    313       
    314   
    315       candidates = if update 
    316                       (class_level_predicates + direct_predicates).compact.uniq 
    317                    else 
    318                      direct_predicates 
    319                     end 
    320  
    321   
    322                         # checking possibility (1) and (3) 
    323                         candidates.each do |pred| 
    324                                 if Namespace.localname(pred) == methodname 
    325           if update 
    326             return set_predicate(pred, args) 
    327           else 
    328    
    329             return get_predicate(pred, flatten) 
    330           end 
    331                                 end 
    332                         end 
     306#      candidates = if update 
     307#                      (class_level_predicates + direct_predicates).compact.uniq 
     308#                   else 
     309#                     direct_predicates 
     310#                    end 
     311# 
     312#  
     313#                       # checking possibility (1) and (3) 
     314#                       candidates.each do |pred| 
     315#                               if Namespace.localname(pred) == methodname 
     316#          if update 
     317#            return set_predicate(pred, args) 
     318#          else 
     319 
     320#            return get_predicate(pred, flatten) 
     321#          end 
     322#                               end 
     323#                       end 
    333324                         
    334325                        raise ActiveRdfError, "could not set #{methodname} to #{args}: no suitable  
     
    342333                        # class_level_predicates. Only if we don't find either, we 
    343334                        # throw "method_missing" 
    344                         candidates = class_level_predicates 
    345  
    346                         # if any of the class_level candidates fits the sought method, then we 
    347                         # found situation (2), so we return nil or [] depending on the {:array => 
    348                         # true} value 
    349                         if candidates.any?{|c| Namespace.localname(c) == methodname} 
    350                                 return_ary = args[0][:array] if args[0].is_a? Hash 
    351                                 if return_ary 
    352                                         return [] 
    353                                 else 
    354                                         return nil 
    355                                 end 
    356                         end 
     335#                       candidates = class_level_predicates 
     336# 
     337#                       # if any of the class_level candidates fits the sought method, then we 
     338#                       # found situation (2), so we return nil or [] depending on the {:array => 
     339#                       # true} value 
     340#                       if candidates.any?{|c| Namespace.localname(c) == methodname} 
     341#                               return_ary = args[0][:array] if args[0].is_a? Hash 
     342#                               if return_ary 
     343#                                       return [] 
     344#                               else 
     345#                                       return nil 
     346#                               end 
     347#                       end 
    357348  
    358349                        # checking possibility (4) 
     
    413404                        localname = localname.to_s 
    414405                        fulluri = RDFS::Resource.new(fulluri) if fulluri.is_a? String 
    415  
    416406                        # predicates is a hash from abbreviation string to full uri resource 
    417407                        @predicates[localname] = fulluri 
     
    427417    end 
    428418 
    429                 # returns all predicates that fall into the domain of the rdf:type of this 
    430                 # resource 
    431                 def class_level_predicates     
    432                         type = Namespace.lookup(:rdf, 'type') 
    433                         domain = Namespace.lookup(:rdfs, 'domain') 
    434       result = Query.new.distinct(:p).where(self,type,:t).where(:p, domain, :t).execute || [] 
    435       $all_predicates_array = $all_predicates_array | result 
    436  
    437       result 
    438                 end 
    439  
    440                 # returns all predicates that are directly defined for this resource 
    441                 def direct_predicates(distinct = true) 
    442         query = nil      
    443                         if distinct 
    444                                 query = Query.new.distinct(:p).where(self, :p, :o) 
    445                         else 
    446                                 query = Query.new.select(:p).where(self, :p, :o) 
    447                 end 
    448      result = query.execute 
    449      $all_predicates_array = $all_predicates_array | result 
    450      result 
    451   
    452                 end 
     419#               # returns all predicates that fall into the domain of the rdf:type of this 
     420#               # resource 
     421#               def class_level_predicates     
     422#                       type = Namespace.lookup(:rdf, 'type') 
     423#                       domain = Namespace.lookup(:rdfs, 'domain') 
     424#      result = Query.new.distinct(:p).where(self,type,:t).where(:p, domain, :t).execute || [] 
     425#      $all_predicates_array = $all_predicates_array | result 
     426# 
     427#      result 
     428#               end 
     429 
     430#               # returns all predicates that are directly defined for this resource 
     431#               def direct_predicates(distinct = true) 
     432#        query = nil      
     433#                       if distinct 
     434#                               query = Query.new.distinct(:p).where(self, :p, :o) 
     435#                       else 
     436#                               query = Query.new.select(:p).where(self, :p, :o) 
     437#               end 
     438#     result = query.execute 
     439#     $all_predicates_array = $all_predicates_array | result 
     440#     result 
     441#  
     442#               end 
    453443 
    454444                def property_accessors 
     
    469459      values.flatten.each {|v| FederationManager.add(self, predicate, v) } 
    470460      #clear cache 
    471       $triple[self.uri]=nil   
     461      Thread.current[:triples][self.uri]=nil   
    472462      values 
    473463    end 
    474     def cache(flatten=false)                
    475       tuple = Hash.new 
    476       properties = Query.new.distinct(:p,:o).where(self, :p, :o).execute(:flatten => flatten)  
    477       if properties == nil  
    478         $triple[self.uri]=tuple 
    479         return 
    480       end      
    481       properties.each do |p,o|      
     464    def cache(flatten=false)              
     465      tuple = Hash.new        
     466      Thread.current[:triples][self.uri]=tuple       
     467      properties = Query.new.distinct(:p,:o).where(self, :p, :o).execute(:flatten => flatten)       
     468       
     469      properties.each do |p,o|     
     470       
    482471        tuple[p] = Array.new if tuple[p] == nil 
    483472        tuple[p] << o       
    484       end 
    485       $triple[self.uri]=tuple 
     473      end    if properties != nil   
    486474        
    487475    end  
    488     def  all_instance_predicates 
    489        cache(true) if $triple[self.uri] == nil    
    490        $triple[self.uri].keys 
     476    def all_instance_predicates 
     477       cache(true) if Thread.current[:triples][self.uri] == nil    
     478       Thread.current[:triples][self.uri].keys 
    491479    end 
    492480#    def get_properties       
    493 #        cache(true) if $triple[self.uri] == nil    
    494 #      $triple[self.uri] 
     481#        cache(true) if Thread.current[:triples][self.uri] == nil    
     482#      Thread.current[:triples][self.uri] 
    495483#    end 
    496484    def get_predicate(predicate, flatten=false)         
    497        cache(flatten) if $triple[self.uri] == nil 
     485       cache(flatten) if Thread.current[:triples][self.uri] == nil 
    498486      #original code 
    499487     # values = Query.new.distinct(:o).where(self, predicate, :o).execute(:flatten => flatten) 
    500        values  = $triple[self.uri][predicate]!= nil && $triple[self.uri][predicate].size == 1 && flatten ?  $triple[self.uri][predicate].first : $triple[self.uri][predicate] 
     488       values  = Thread.current[:triples][self.uri][predicate]!= nil && Thread.current[:triples][self.uri][predicate].size == 1 && flatten ?  Thread.current[:triples][self.uri][predicate].first : Thread.current[:triples][self.uri][predicate] 
    501489       
    502490       values = Array.new if values == nil && flatten==false