rtm 0.1.6 → 0.2.0

data/lib/rtm/backend/active_record/tmdm.rb

@@ -1,298 +0,0 @@
-old_verbose=$VERBOSE
-$VERBOSE=false
-require 'active_record'
-$VERBOSE=old_verbose
-
-module RTM::AR
-  # The Active Record TMDM backend
-  module TMDM
-    # Moves all fields in a collection to another owner (for classes using belongs_to in AR::Base class)
-    module Movable
-      # Takes a list of [field,from, to] arguments.
-      # RTM::AR::TMDM::ItemIdentifier.move_all(
-      #      ["topic_map_construct_id", other.__getobj__.id, self.__getobj__.id],
-      #      ["topic_map_construct_type", other.__getobj__.class.name, self.__getobj__.class.name]
-      #    )
-      # or
-      # RTM::AR::TMDM::Variant.move_all(["topic_name_id", other.__getobj__.id, self.__getobj__.id])
-
-      # 
-      def move_all(*args)
-        raise "All parameters must have a size of 3: [field_name, from, to]" unless args.all?{|a| a.size == 3}
-        set_part = ""
-        where_part = ""
-        args.each do |field, from, to|
-          set_part += ", " unless set_part.empty?
-          where_part += " and " unless where_part.empty?
-          from = "'#{from}'" unless from.is_a? Numeric
-          to = "'#{to}'" unless to.is_a? Numeric
-          where_part += "#{field} = #{from}"
-          set_part += "#{field} = #{to}"
-        end
-        #puts "setpart: #{set_part.inspect}\nwherepart: #{where_part.inspect}"
-        res = self.update_all(set_part, where_part)
-        #puts "result: #{res.inspect}"
-      end
-    end
-
-    class TopicMapConstruct < ActiveRecord::Base
-      self.store_full_sti_class = false 
-      extend Movable
-      class << self
-        def abstract_class?
-          self == TopicMapConstruct
-        end
-        def alias_ar_relation(new,old)
-          alias_method new, old
-          alias_method "#{new}=", "#{old}="
-        end
-        alias :alias_belongs_to  :alias_ar_relation
-        alias :alias_has_many :alias_ar_relation
-        def belongs_to_with_alias(name, synonym)
-          belongs_to name
-          alias_belongs_to synonym, name
-        end
-        def has_many_with_alias(name, synonym, *args)
-          has_many name, *args
-          alias_has_many synonym, name
-        end
-        def belongs_to_parent(parent)
-          belongs_to parent
-          alias_belongs_to :parent, parent
-        end
-        def this_is_a_typed_object
-          belongs_to :ttype, :class_name => "Topic", :foreign_key => :ttype_id
-          module_eval(<<-EOS, "(__RTM_AR_TMDM_TYPED_OBJECT__)", 1)
-          def type=(ptype)
-            self.ttype=ptype
-          end
-          def type
-            self.ttype
-          end
-          EOS
-        end
-      end
-      has_many :item_identifiers, :as => :topic_map_construct, :dependent => :destroy
-      def topic_map
-        parent.topic_map
-      end
-      def move_to(new_parent)
-        self.parent = new_parent
-      end
-
-    end
-    class Reifiable < TopicMapConstruct
-      def self.abstract_class?
-        self == Reifiable
-      end
-      has_one :reifier, :class_name => "Topic", :as => :reified
-    end
-    class ScopedObject < Reifiable
-      def self.abstract_class?
-        self == ScopedObject
-      end
-      has_many :scoped_objects_topics, :as => :scoped_object, :dependent => :destroy
-      has_many :scope, :through => :scoped_objects_topics, :source => :topic
-#      def scope
-#        self.scoped_objects_topics.map { |sot| sot.topic }
-#      end
-#      def add_scoping_topic(topic) # this is not ruby-ish but at least it works, would need a complete association proxy instead...
-#        sot = ScopedObjectsTopic.create :topic => topic, :scoped_object => self
-#        self
-#        #      sot = ScopedObjectsTopic.new :topic => topic, :scoped_object => self
-#        #      self.scoped_objects_topics << sot
-#        #      self
-#      end
-#      def remove_scoping_topic(topic) # this is not ruby-ish but at least it works, would need a complete association proxy instead...
-#        self.scoped_objects_topics.select { |sot| sot.topic == topic }.destroy
-#        self
-#      end
-    end
-    class ScopedObjectsTopic < ActiveRecord::Base
-      self.store_full_sti_class = false 
-      extend Movable
-      belongs_to :topic
-      belongs_to :scoped_object, :polymorphic => true
-      belongs_to :association, :class_name => 'RTM::AR::TMDM::Association', :foreign_key => "scoped_object_id"
-      belongs_to :topic_name, :class_name => 'RTM::AR::TMDM::TopicName', :foreign_key => "scoped_object_id"
-      belongs_to :variant, :class_name => 'RTM::AR::TMDM::Variant', :foreign_key => "scoped_object_id"
-      belongs_to :occurrence, :class_name => 'RTM::AR::TMDM::Occurrence', :foreign_key => "scoped_object_id"
-    end
-  
-    class Locator < ActiveRecord::Base
-      self.store_full_sti_class = false 
-      extend Movable
-      class << self
-        def abstract_class?
-          self == Locator
-        end
-      end
-      belongs_to :topic_map
-    end
-
-    class ItemIdentifier < Locator
-      belongs_to :topic_map_construct, :polymorphic => true
-      def to_s
-        self.reference
-      end
-      def move_to(new_tmc)
-        #puts "\n\nmoving\n\t#{self.inspect}\n\nto\n\t#{new_tmc.inspect}"
-        #self.update_all "topic_map_construct_id = #{new_tmc.id}, topic_map_construct_type = '#{new_tmc.class.name}'", 
-        #puts "changing id"
-        #puts self.topic_map_construct_id = new_tmc.id
-        #puts "changing type"
-        #puts self.topic_map_construct_type = new_tmc.class.name
-        self.topic_map_construct = new_tmc
-        #puts "saving"
-        self.save
-        #
-        # das geht!!!
-        #self.class.update( self.id, "topic_map_construct_id" => new_tmc.id)
-      end
-    end
-    class SubjectLocator < Locator
-      belongs_to :topic
-      def to_s
-        self.reference
-      end
-    end
-    class SubjectIdentifier < Locator
-      belongs_to :topic
-      def to_s
-        self.reference
-      end
-    end
-    # http://www.isotopicmaps.org/sam/sam-model/#d0e736
-    class Topic < TopicMapConstruct
-      belongs_to :reified, :polymorphic => true
-      belongs_to_parent :topic_map
-      has_many :subject_locators, :dependent => :destroy
-      has_many :subject_identifiers, :dependent => :destroy
-      has_many :occurrences, :dependent => :destroy
-      has_many_with_alias :topic_names, :names, :dependent => :destroy
-      has_many_with_alias :association_roles, :roles, :include => :association
-      has_many :associations, :through => :association_roles
-      #has_many :played_types, :through => :association_roles, :source => :type
-      
-      has_many :associations_typed, :class_name => "Association", :foreign_key => :ttype_id
-      has_many :association_roles_typed, :class_name => "AssociationRole", :foreign_key => :ttype_id
-      has_many :topic_names_typed, :class_name => "TopicName", :foreign_key => :ttype_id
-      has_many :occurrences_typed, :class_name => "Occurrence", :foreign_key => :ttype_id
-    
-      has_many :scoped_objects_topics
-      has_many :scoped_associations, :through => :scoped_objects_topics, :source => :association,
-        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Association'"
-      has_many :scoped_topic_names, :through => :scoped_objects_topics, :source => :topic_name,
-        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::TopicName'"
-      has_many :scoped_variants, :through => :scoped_objects_topics, :source => :variant,
-        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Variant'"
-      has_many :scoped_occurrences, :through => :scoped_objects_topics, :source => :occurrence,
-        :conditions => "scoped_objects_topics.scoped_object_type = 'RTM::AR::TMDM::Occurrence'"
-
-#      def scoped_objects
-#        self.scoped_objects_topics.collect { |a| a.scoped_object } # temporary hack polymorphic has_many_through
-#      end
-      def scoped_objects
-        scoped_associations + scoped_topic_names + scoped_variants + scoped_occurrences
-      end
-
-    end
-
-    class AssociationRole < Reifiable
-      belongs_to_parent :association
-      belongs_to_with_alias :topic, :player
-      this_is_a_typed_object
-    end
-
-    class TopicName < ScopedObject
-      belongs_to_parent :topic
-      this_is_a_typed_object
-      has_many :variants, :dependent => :destroy
-    end
-
-    class Association < ScopedObject
-      belongs_to_parent :topic_map
-      this_is_a_typed_object
-      has_many_with_alias :association_roles, :roles, :dependent => :destroy
-      def create_role(rplayer, ttype)
-        AssociationRole.create :parent => self, :player => rplayer, :ttype => ttype
-      end
-      alias :create_association_role :create_role
-      has_many :role_players, :through => :association_roles, :source => :topic
-      has_many :role_types, :through => :association_roles, :source => :ttype
-    end
-    
-    class AssociationCache < TopicMapConstruct
-      set_table_name "associations_cache"
-      belongs_to_parent :topic_map
-      this_is_a_typed_object
-      has_many_with_alias :association_roles, :roles
-      belongs_to :role1, :class_name => "RTM::AR::TMDM::AssociationRole", :foreign_key => "role1_id"
-      belongs_to :player1, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "player1_id"
-      belongs_to :type1, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "type1_id"
-      belongs_to :role2, :class_name => "RTM::AR::TMDM::AssociationRole", :foreign_key => "role2_id"
-      belongs_to :player2, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "player2_id"
-      belongs_to :type2, :class_name => "RTM::AR::TMDM::Topic", :foreign_key => "type2_id"
-      # rolecount -> rcnt
-    end
-
-    class Occurrence < ScopedObject
-      belongs_to_parent :topic
-      this_is_a_typed_object
-    end
-
-    class Variant < ScopedObject
-      belongs_to_parent :topic_name
-    end
-
-    class TopicMap < Reifiable
-      # real properties
-      has_many :topics, :dependent => :destroy, :include => [:subject_identifiers, :subject_locators]
-      has_many :associations, :dependent => :destroy, :include => :association_roles
-      
-      # access to subproperties
-      has_many :locators, :class_name => "ItemIdentifier", :dependent => :destroy
-      has_many :subject_locators, :dependent => :destroy
-      has_many :subject_identifiers, :dependent => :destroy
-
-      has_many :topic_names, :through => :topics
-      alias :names :topic_names
-      has_many :occurrences, :through => :topics
-      has_many :association_roles, :through => :associations
-      alias :roles :association_roles
-      
-      %w[association association_role topic_name occurrence].each do |m|
-        module_eval(<<-EOS, "(__AR_DELEGATOR_INDEX_PROPERTY_SET__)", 1)
-          def #{m}_types
-            topics.select{|t| t.#{m}s_typed.size > 0}
-          end
-        EOS
-      end
-      
-      #typing
-#      has_many :association_types, :class_name => "Association", :foreign_key => :ttype_id
-#      has_many :association_role_types, :class_name => "AssociationRole", :foreign_key => :ttype_id
-#      has_many :topic_name_types, :class_name => "TopicName", :foreign_key => :ttype_id
-#      has_many :occurrence_types, :class_name => "Occurrence", :foreign_key => :ttype_id
-
-#      has_many :association_types, :aka => :at, :type => :Topic, :wrap => true
-#      has_many :association_role_types, :aka => [:role_types,:art,:rt], :type => :Topic, :wrap => true
-#      has_many :topic_name_types, :aka => [:name_types,:tnt,:nt], :type => :Topic, :wrap => true
-#      has_many :occurrence_types, :aka => :ot, :type => :Topic, :wrap => true
-
-      
-      def topic_map
-        self
-      end
-
-#      # Creates a new Locator in this TopicMap
-#      def create_locator(reference, notation=nil)
-#        if notation
-#          ItemIdentifier.create :reference => reference, :notation => notation
-#        else
-#          ItemIdentifier.create :reference => reference # is there a better way to preserve the database default notation if none given?
-#        end
-#      end
-    end
-  end
-end

data/lib/rtm/backend/active_record/topic.rb

@@ -1,87 +0,0 @@
-module RTM::AR
-  class Topic < TopicMapConstruct
-    include RTM::Topic
-    wrapper_cache
-
-    parent :topic_map
-    property_set :subject_identifiers, :aka => [:si,:sid], :type => :SubjectIdentifier, :wrap => true,
-      #:create => :subject_identifier, :create_aka => [:csi,:csid],
-      #:create_args => [{:name => :reference, :type => :String}]
-      :add => true, :remove => true
-    property_set :subject_locators, :aka => [:sl,:slo], :type => :SubjectLocator, :wrap => true,
-      #:create => :subject_locator, :create_aka => [:csl, :cslo],
-      #:create_args => [{:name => :reference, :type => :String}]
-      :add => true, :remove => true
-
-    property :reified, :computable => true, :type => :Reifiable, :wrap => true
-
-    property_set :topic_names, :aka => [:n, :names], :type => :TopicName, :wrap => true,
-      :create => :topic_name, :create_aka => [:create_name, :cn], 
-      :create_args => [ {:name => :value, :type => :String}, {:name => :type, :type => :Topic, :optional => true}, {:name => :scope, :type => :Collection} ]
-
-    property_set :occurrences, :aka => :o, :type => :Occurrence, :wrap => true,
-      :create => :occurrence, :create_aka => :co,
-      :create_args => [ {:name => :value, :type => [:String, :Locator]}, {:name => :type, :type => :Topic}, {:name => :scope, :type => :Collection} ]
-
-    property_set :roles, :aka => [:r, :roles_played, :association_roles], :computable => true, :type => :AssociationRole, :wrap => true
-
-    property_set :associations, :aka => [:a, :associations_played], :type => :Association, :wrap => true
-
-    property_set :scoped_objects, :type => :TopicMapConstruct, :wrap => true
-    property_set :scoped_associations, :type => :Association, :wrap => true
-    property_set :scoped_topic_names, :aka => :scoped_names, :type => :TopicName, :wrap => true
-    property_set :scoped_variants, :type => :Variant, :wrap => true
-    property_set :scoped_occurrences, :type => :Occurrence, :wrap => true
-
-    property_set :associations_typed, :aka => :at, :type => :Association, :wrap => true
-    property_set :association_roles_typed, :aka => [:roles_typed,:art,:rt], :type => :AssociationRole, :wrap => true
-    property_set :topic_names_typed, :aka => [:names_typed,:tnt,:nt], :type => :TopicName, :wrap => true
-    property_set :occurrences_typed, :aka => :ot, :type => :Occurrence, :wrap => true
-    
-    require 'rtm/sugar/topic/characteristics'
-    include RTM::Sugar::Topic::Characteristics
-    require 'rtm/sugar/topic/counterparts'
-    include RTM::Sugar::Topic::Counterparts
-    require 'rtm/sugar/topic/identifier_direct'
-    include RTM::Sugar::Topic::IdentifierDirect
-    require 'rtm/sugar/topic/hash_access'
-    include RTM::Sugar::Topic::HashAccess
-    require 'rtm/sugar/topic/predefined_associations'
-    include RTM::Sugar::Topic::PredefinedAssociations
-
-    # class:Topic equality, http://www.isotopicmaps.org/sam/sam-model/#d0e1029
-    #
-    # This method is all crap. These ActiveRecord Arrays can't be intersected,
-    # so I map the identifiers to their reference which seems long winded.
-    # Still I find it better than using their ID in the long.
-    # 
-    def ==(o)
-      return false unless o
-      # Two topic items are equal if they have:
-      # * at least one equal string in their [subject identifiers] properties,
-      # -> test if intersection are > 0
-      my_si = self.subject_identifiers.map{|si| si.reference}
-      ot_si = o.subject_identifiers.map{|si| si.reference}
-      return true if ( my_si & ot_si).size > 0 
-
-      # * at least one equal string in their [item identifiers] properties,
-      my_ii = self.item_identifiers.map{|ii| ii.reference}
-      ot_ii = o.item_identifiers.map{|ii| ii.reference}
-      return true if (my_ii & ot_ii).size > 0 
-
-      # * at least one equal string in their [subject locators] properties,
-      my_sl = self.subject_locators.map{|sl| sl.reference}
-      ot_sl = o.subject_locators.map{|sl| sl.reference}
-      return true if (my_sl & ot_sl).size > 0 
-
-      # * an equal string in the [subject identifiers] property of the one topic item and the [item identifiers] property of the other, or
-      return true if (my_si & ot_ii).size > 0 
-      return true if (my_ii & ot_si).size > 0 
-
-      # * the same information item in their [reified] properties.
-      return true if self.reified != nil && o.reified != nil && (self.reified == o.reified)
-      # ... otherwise
-      false
-    end
-  end
-end

data/lib/rtm/backend/active_record/topic_map.rb

@@ -1,314 +0,0 @@
-module RTM::AR
-  class TopicMap < Reifiable
-    include RTM::TopicMap
-    wrapper_cache
-    property_set :topics, :aka => :t, :type => :Topic, :wrap => true,
-      :create => :topic,  :create_aka => :ct
-     
-    property_set :associations, :aka => [:a, :assocs], :type => :Association, :wrap => true,
-      :create => :association, :create_aka => :ca,
-      :create_args => [{:name => :type, :type => :Topic}]
-
-
-    delegate :base_locator
-
-    property_set :association_types, :aka => :at, :type => :Topic, :wrap => true
-    property_set :association_role_types, :aka => [:role_types,:art,:rt], :type => :Topic, :wrap => true
-    property_set :topic_name_types, :aka => [:name_types,:tnt,:nt], :type => :Topic, :wrap => true
-    property_set :occurrence_types, :aka => :ot, :type => :Topic, :wrap => true
-    
-    property_set :topic_names, :aka => [:names,:n], :type => :TopicName, :wrap => :true
-    property_set :occurrences, :aka => :o, :type => :Occurrence, :wrap => :true
-    property_set :association_roles, :aka => [:roles, :r], :type => :AssociationRole, :wrap => :true
-
-    def types
-      topics.select{|t| t.instances.size > 0}
-    end
-    alias :topic_types :types
-    def fast_types
-      
-    end
-    
-    # This fetches all topics who have no topic-instances (but they might be types for associations etc.).
-    # See indivduals
-    def non_types
-      topics.select{|t| t.instances.size == 0}
-    end
-    
-    # This fetches all topics which are not type for something else (including topics, associations etc.).
-    # See non_types
-    def individuals
-      non_types.select{|t| t.associations_typed.size==0 && t.roles_typed.size==0 && t.names_typed.size==0 && t.occurrences_typed.size==0}
-    end
-    def instances
-      topics.select{|t| t.types.size > 0}
-    end
-    def non_instances
-      topics.reject{|t| t.types.size > 0}
-    end
-    def internal_occurrences
-      occurrences.select{|o| o.datatype != RTM::PSI[:IRI]}
-    end
-    def external_occurrences
-      occurrences.select{|o| o.datatype == RTM::PSI[:IRI]}
-    end
-    
-    def self.create(base_locator, params={})
-      bl_uri = URI.parse(base_locator)
-      raise "The locator for the Topic Map must be absolute! \"#{base_locator}\" is not an absolute locator." unless bl_uri.absolute?
-      tm = self.wrap(TMDM::TopicMap.find_or_create_by_base_locator(base_locator))
-      yield tm if block_given?
-      tm
-    end
-
-    def self.topic_maps
-      TopicMaps.wrap(TMDM::TopicMap.find(:all))
-    end
-
-    # Resolves an IRI or fragment relative to the base_locator of this topic_map or an optional given alternative_base_locator
-    # 
-    # Absolute IRIs are taken as is.
-    # 
-    # Relative IRIs:
-    # If the base_locator is a directory (ends with "/") it is appended like a file, i.e. directly
-    # If the base_locator is a file it is appended as a fragment (with # in between)
-    def resolve(obj,alternative_base_locator=nil)
-      uri = obj.to_s
-# TODO     uri = URI.decode(obj.to_s) # this InvalidURIError somethimes :(
-      begin
-        uri_uri = URI.parse(uri)
-      rescue URI::InvalidComponentError => ice
-        warn "Catched an URI::InvalidComponentError for URI: #{uri}, message was \"#{ice.message}\"\n" +
-          "Will continue using the UNRESOLVED IRI, claiming it is absolute."
-        return uri
-      end
-      if uri_uri.absolute?
-        return uri_uri.to_s
-      end
-      
-      uri = uri[1..-1] if uri[0] == "#"[0]
-      bl = alternative_base_locator || base_locator
-      if bl[-1,1] == "/"
-        return bl + uri
-      else
-        return bl + "#" + uri
-      end
-    end
-    
-    #private
-    
-    def _item_identifier(iid)
-      __getobj__.locators.find_by_reference(resolve(iid)) # doesn't work :( --> , :include => [ :topic_map_construct ])
-    end
-    def _item_identifier!(iid)
-      __getobj__.locators.find_or_create_by_reference(resolve(iid)) # doesn't work :( --> , :include => [ :topic_map_construct ])
-    end
-    
-    def _subject_identifier(iid)
-      __getobj__.subject_identifiers.find_by_reference(iid, :include => :topic)
-    end
-    def _subject_identifier!(iid)
-      __getobj__.subject_identifiers.find_or_create_by_reference(iid, :include => :topic)
-    end
-    
-    def _subject_locator(iid)
-      __getobj__.subject_locators.find_by_reference(iid, :include => :topic)
-    end
-    def _subject_locator!(iid)
-      __getobj__.subject_locators.find_or_create_by_reference(iid, :include => :topic)
-    end
-    
-    
-    # internal helper for by_item_identifier, doesn't wrap result
-    def _by_item_identifier(iid)
-      iid = RTM::LocatorHelpers.iid2iri(iid) if RTM::LocatorHelpers.is_a_iid?(iid)
-      ii = __getobj__.locators.find_by_reference(resolve(iid)) #, :include => [ :topic_map_construct ])
-      return ii.topic_map_construct if ii
-      nil
-    end
-    def _topic_by_item_identifier(iid)
-      t = _by_item_identifier(iid)
-      return nil unless t
-      return t if t.class.name =~ /::Topic$/ # only return something if the thing is a topic
-      nil
-    end
-    
-    # internal helper for topic_by_item_identifier!, doesn't wrap result
-    def _topic_by_item_identifier!(iid)
-      iid = RTM::LocatorHelpers.iid2iri(iid) if RTM::LocatorHelpers.is_a_iid?(iid)
-      ii = __getobj__.locators.find_or_create_by_reference(resolve(iid))#, :include => [ :topic_map_construct ])
-      return ii.topic_map_construct if ii.topic_map_construct && ii.topic_map_construct_type =~ /::Topic$/
-      top2 = _topic_by_subject_identifier(resolve(iid))
-      if top2
-        ii.topic_map_construct = top2
-      else
-        ii.topic_map_construct = create_topic.__getobj__
-      end
-      ii.save
-      ii.topic_map_construct
-    end        
-    # internal helper for topic_by_subject_identifier, doesn't wrap result
-    def _topic_by_subject_identifier(sid)
-      si = __getobj__.subject_identifiers.find_by_reference(sid, :include => [ :topic ])
-      return si.topic if si
-      nil
-    end
-    # internal helper for topic_by_subject_identifier!, doesn't wrap result
-    def _topic_by_subject_identifier!(sid)
-      si =  __getobj__.subject_identifiers.find_or_create_by_reference(sid, :include => [ :topic ])
-      return si.topic if si.topic
-      begin
-      top2 = _by_item_identifier(sid)
-      rescue ActiveRecord::RecordNotFound => rnf
-        si.topic = create_topic.__getobj__
-      else
-        if top2 && top2.respond_to?(:subject_identifiers)
-          si.topic = top2
-        else
-          si.topic = create_topic.__getobj__
-        end
-      end
-      si.save
-      si.topic
-    end
-
-    # internal helper for topic_by_subject_locator, doesn't wrap result
-    def _topic_by_subject_locator(slo)
-      sl = __getobj__.subject_locators.find_by_reference(RTM::LocatorHelpers.slo2iri(slo)) #, :include => [ :topic ])
-      return sl.topic if sl
-      nil
-    end
-
-    # internal helper for topic_by_subject_locator!, doesn't wrap result
-    def _topic_by_subject_locator!(slo)
-      sl = __getobj__.subject_locators.find_or_create_by_reference(RTM::LocatorHelpers.slo2iri(slo), :include => [ :topic ])
-      return sl.topic if sl.topic
-      sl.topic = create_topic.__getobj__
-      sl.save
-      sl.topic
-    end
-    def _topic_by_locator(iri)
-      raise "Locator may not be nil" unless iri
-      if RTM::LocatorHelpers.is_a_slo?(iri)
-        _topic_by_subject_locator(iri)
-      elsif RTM::LocatorHelpers.is_a_iid?(iri)
-        _topic_by_item_identifier(iri)
-      elsif URI.parse(iri).absolute?
-        _topic_by_subject_identifier(iri)
-      else
-        _topic_by_item_identifier(iri)
-      end
-    end
-
-    def _topic_by_locator!(iri)
-      raise "Locator may not be nil" unless iri
-      if RTM::LocatorHelpers.is_a_slo?(iri)
-        _topic_by_subject_locator!(iri)
-      elsif RTM::LocatorHelpers.is_a_iid?(iri)
-        _topic_by_item_identifier!(iri)
-      elsif URI.parse(iri).absolute?
-        _topic_by_subject_identifier!(iri)
-      else
-        _topic_by_item_identifier!(iri)
-      end
-    end
-    
-    %w[topic association role name occurrence variant].each do |x|
-      eval <<-EOI
-        def _#{x}_by_id(id)
-          __getobj__.#{x}s.find(id)
-        end
-      EOI
-    end
-    public
-    # returns an item identifier from the topic_map if it exists
-    def item_identifier(iid)
-      ItemIdentifier.wrap(_item_identifier(iid))
-    end
-    # returns an item identififier from the topic_map or creates it if it doesn't exist
-    def item_identifier!(iid)
-      ItemIdentifier.wrap(_item_identifier!(iid))
-    end
-    alias :create_locator :item_identifier!
-    # Returns a topic map construct by it's item identifier or nil if not found.
-    # It's the equivalent to TMAPI's TopicMapObjectIndex.getTopicMapObjectBySourceLocator
-    def by_item_identifier(iid)
-      TopicMapConstruct.wrap(_by_item_identifier(iid))
-    end
-    # Returns a topic by it's item identifier. The topic will be created if not found.
-    def topic_by_item_identifier!(iid)
-      Topic.wrap(_topic_by_item_identifier!(iid))
-    end
-    # Returns a topic by it's subject identifier or nil if not found.
-    # It's the equivalent to TMAPI's TopicsIndex.getTopicBySubjectIdentifier.
-    def topic_by_subject_identifier(sid)
-      Topic.wrap(_topic_by_subject_identifier(sid))
-    end
-    # returns a topic by it's subject identifier. The topic will be created if not found.
-    def topic_by_subject_identifier!(sid)
-      Topic.wrap(_topic_by_subject_identifier!(sid))
-    end
-    # Returns a topic by it's subject locator or nil if not found.
-    # It's the equivalent to TMAPI's TopicsIndex.getTopicBySubjectLocator
-    def topic_by_subject_locator(slo)
-      Topic.wrap(_topic_by_subject_locator(slo))
-    end
-    # returns a topic by it's subject locator. The topic will be created if not found.
-    def topic_by_subject_locator!(slo)
-      Topic.wrap(_topic_by_subject_locator!(slo))
-    end
-    
-    # Gets a topic from this topic map using its (relative) item identifier,
-    # its (absolute) subject identifier or its (absolute and by "=" prepended) subject locator)
-    #
-    # Returns nil if the Topic does not exist.
-    #
-    # It's also possible to pass a number, which is used to fetch a topic using the internal id. In this case, an exception is thrown, if the topic does not exist.
-    #
-    def topic_by_locator(iri)
-      return iri if iri.is_a? Topic
-      return topic_by_id(iri) if iri.is_a? Integer
-#      @tblc ||= {}
-#      t = @tblc[iri]
-#      return t if t
-      t = Topic.wrap(_topic_by_locator(iri))
-#      @tblc[iri] = t if t
-#      t
-    end
-    alias :get :topic_by_locator
-
-    # Gets a topic from this topic map using its (relative) item identifier,
-    # its (absolute) subject identifier or its (absolute and by "=" prepended) subject locator)
-    #
-    # If there is no topic with this item identifier, subject identifier or subject locator, it is created.
-    # Please be aware, the creation does not work with the internal (numeric) ids.
-    # 
-    def topic_by_locator!(iri)
-      return iri if iri.is_a? Topic
-      return topic_by_id(iri) if iri.is_a? Integer
-#      @tblc ||= {}
-#      t = @tblc[iri]
-#      return t if t
-      t = Topic.wrap(_topic_by_locator!(iri))
-#      @tblc[iri] = t
-#      t
-    end
-    alias :get! :topic_by_locator!
-    
-    %w[topic association role name occurrence variant].each do |x|
-      eval <<-EOI
-        def #{x}_by_id(id)
-          #{x.camelize}.wrap(_#{x}_by_id(id))
-        end
-        alias :#{x[0].chr}id :#{x}_by_id
-      EOI
-    end
-
-    # I am not sure if this is at all correct. TMDM doesn't say a word about it
-    # and the approach to compare topic maps is CXTM. I chose this because we 
-    # should (at least at the time of writing) have only one topic with a given
-    # base locator in RTM. If you don't like it, drop me a mail and explain why
-    # and propose something better.
-    equality [:base_locator]
-  end
-end