rtm-javatmapi 0.2.0

data/lib/rtm/javatmapi/core/scoped.rb

@@ -0,0 +1,99 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Java::OrgTmapiCore::Scoped
+
+  extend Superiseable
+  #include RTM::Scoped
+
+  # Returns the Topics which define the scope of this scoped Construct.
+  # An empty Set represents the unconstrained scope.
+  #
+  # :call-seq:
+  #   scope -> Set of Topics
+  #
+  def scope
+    getScope
+  end
+  alias :themes :scope
+
+  superised
+  # Adds a topic given by the identifier to the scope.
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   add_theme(identifier)
+  #
+	def add_theme(identifier)
+    if identifier.is_a?(Java::OrgTmapiCore::Topic)
+      addTheme(identifier)
+    elsif identifier.is_a?(Java::OrgTmapiCore::Locator) || identifier.is_a?(String)
+      addTheme(topic_map.get!(identifier))
+    else
+      raise("Identifier must be a Topic, String or Locator")
+    end
+	end
+
+  # Adds one or several topics to the scope.
+  #
+  # An identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   add_themes(identifier)
+  #   add_themes(identifier1, identifier2, ...)
+  #
+  def add_themes(*args)
+    args.flatten!
+    args.each do |identifier|
+      add_theme(identifier)
+    end
+	end
+  alias :add_scope :add_themes
+
+  # Future version, TODO
+  #  def set_scope(*args)
+  #
+  #  end
+  #  alias :scope= :set_scope
+
+  superised
+  # Removes a topic given by the identifier from the current scope.
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   remove_theme(identifier)
+  #
+	def remove_theme(identifier)
+    if identifier.is_a?(Java::OrgTmapiCore::Topic)
+      removeTheme(identifier)
+    elsif identifier.is_a?(Java::OrgTmapiCore::Locator) || identifier.is_a?(String)
+      removeTheme(topic_map.get!(identifier))
+    else
+      raise("Identifier must be a Topic, String or Locator")
+    end
+	end
+
+  # Removes one or several topics from the scope.
+  #
+  # An identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   remove_themes(identifier)
+  #   remove_themes(identifier1, identifier2, ...)
+  #
+	def remove_themes(*args)
+    args.flatten!
+    args.each do |identifier|
+      remove_theme(identifier)
+    end
+	end
+  alias :remove_scope :remove_themes
+
+  # Future version, TODO
+  #  def delete_scope(*args)
+  #
+  #  end
+
+end

data/lib/rtm/javatmapi/core/topic.rb

@@ -0,0 +1,454 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Java::OrgTmapiCore::Topic
+ 
+  #include RTM::Topic
+  extend Superiseable
+ 
+  # Returns all Names and Occurrences parented by this Topic.
+  #
+  # :call-seq:
+  #   children -> Array of Names and/or Occurrences
+  #
+  def children
+    getNames.to_a +	getOccurrences.to_a
+  end
+  alias :reverse_parent :children
+
+  superised
+  # Returns Names of this Topic.
+  #
+  # If identifier is given, returns the Names
+  # of this Topic for which the Name type equals identifier.
+  # If several identifiers are given, returns the union
+  # of all Names of this Topic, which have one of
+  # the identifiers as Name type. 
+  #
+  # If the identifier equals :default, all Names
+  # which have the default Name type are returned.
+  #
+  # Identifier may be a Topic/Topic-Reference or Symbol;
+  # or an Array of these.
+  #
+  # :call-seq:
+  #   names     -> Set of Names
+  #   names(identifier) -> Set of Names
+  #
+  def names(*args)
+    identifier = args.flatten
+    return getNames if identifier.empty?
+    if identifier.size > 1
+      result = java.util.HashSet.new
+      identifier.each{|i| result.addAll(names(i))}
+      return result
+    else
+      identifier = identifier[0]
+      return getNames if identifier == :any
+      return getNames(topic_map.get(RTM::PSI[:name_type])) if identifier == :default
+      identifier = topic_map.get(identifier)
+      return java.util.HashSet.new unless identifier
+      return getNames(identifier)
+    end
+  end
+
+  superised
+  # Returns Occurrences of this Topic.
+  #
+  # If identifier is given, returns the Occurrences
+  # of this Topic for which the Occurrence type equals identifier.
+  # If several identifiers are given, returns the union
+  # of all Occurrences of this Topic, which have one of
+  # the identifiers as Occurrence type. 
+  #
+  # Identifier may be a Topic/Topic-Reference or an Array of these.
+  # 
+  # :call-seq:
+  #   occurrences           -> Set of Occurrences
+  #   occurrences(identifier) -> Set of Occurrences
+  #
+  def occurrences(*args)
+    identifier = args.flatten
+    return getOccurrences if identifier.empty?
+    if identifier.size > 1
+      result = java.util.HashSet.new
+      identifier.each{|i| result.addAll(occurrences(i))}
+      return result
+    else
+      identifier = identifier[0]
+      return getOccurrences if identifier == :any
+      identifier = topic_map.get(identifier)
+      return java.util.HashSet.new unless identifier
+      return getOccurrences(identifier)
+    end
+  end
+
+  superised
+  # Creates a Name for this Topic with the specified value.
+  # Value has to be a String.
+  #
+  # Type may be a Topic/Topic-Reference.
+  # If given, type specifies the Name Type;
+  # else the created Name will have the default name type.
+  # 
+  # Scope must be an Array of Topics/Topic-References.
+  # If given, scope specifies the Name scope; else the Name is
+  # in the unconstrained scope.
+  #
+  # :call-seq:
+  #   create_name(value)              -> Name
+  #   create_name(value, scope)       -> Name
+  #   create_name(type, value)        -> Name
+  #   create_name(type, value, scope) -> Name
+  #
+  def create_name(arg1,arg2 = :nothing, arg3 = :nothing)
+    if (arg2 == :nothing) && (arg3 == :nothing) #arg1 = value
+      raise "create_name(value): value must be a String" unless arg1.is_a?(String)
+      return createName(arg1,[].to_java(org.tmapi.core.Topic))
+    end
+    if (arg3 == :nothing)
+      if arg2.is_a?(Array) #arg1 = value, arg2 = scope
+        raise "create_name(value, scope): value must be a String" unless arg1.is_a?(String)
+        arg2.each do |theme|
+          raise "create_name(value, scope): scope must be an Array of Topics/Topic-References" unless (theme.is_a?(String) || theme.is_a?(Java::OrgTmapiCore::Topic) || theme.is_a?(Java::OrgTmapiCore::Locator))
+        end
+        return arg2.empty? ? createName(arg1,[].to_java(org.tmapi.core.Topic)) : createName(arg1,topic_map.get!(arg2))
+      elsif arg2.is_a?(String) #arg1 = type, arg2 = value
+        raise "create_name(type, value): type must be a Topic/Topic-Reference" unless (arg1.is_a?(String) || arg1.is_a?(Java::OrgTmapiCore::Topic) || arg1.is_a?(Java::OrgTmapiCore::Locator))
+        return createName(topic_map.get!(arg1),arg2,[].to_java(org.tmapi.core.Topic))
+      else
+        raise "create_name(?,?): arguments don't match"
+      end
+    end
+    #arg1 = type, arg2 = value, arg3 = scope
+    raise "create_name(type, value, scope): type must be a Topic/Topic-Reference" unless (arg1.is_a?(String) || arg1.is_a?(Java::OrgTmapiCore::Topic) || arg1.is_a?(Java::OrgTmapiCore::Locator))
+    raise "create_name(type, value, scope): value must be a String" unless arg2.is_a?(String)
+    raise "create_name(type, value, scope): scope must be an Array" unless arg3.is_a?(Array)
+    arg3.each do |theme|
+      raise "create_name(type, value, scope): scope must be an Array of Topics/Topic-References" unless (theme.is_a?(String) || theme.is_a?(Java::OrgTmapiCore::Topic) || theme.is_a?(Java::OrgTmapiCore::Locator))
+    end
+    return createName(topic_map.get!(arg1),arg2,topic_map.get!(arg3))
+  end
+
+  superised
+  # Creates an Occurrence for this Topic with the specified type and value and
+  # optional scope and datatype.
+  #
+  # Type specifies the Occurrence type and may be a Topic, String or Locator.
+  #
+  # Value may be a Locator (then the datatype is set to xsd:AnyURI and
+  # must not be given) or String.
+  #
+  # Scope may be an Array of Topics/Topic-References. If no scope
+  # is given, the Occurrence will be in the unconstrained scope.
+  #
+  # Datatype may be a String or Locator and indicates the datatype of the value.
+  #
+  # :call-seq:
+  #   create_occurrence(type, value)                                           -> Occurrence
+  #   create_occurrence(type, value, {:scope => scope})                        -> Occurrence
+  #   create_occurrence(type, value, {:datatype => datatype, :scope => scope}) -> Occurrence
+  #   create_occurrence(type, value, {:datatype => datatype})                  -> Occurrence
+  #  
+  def create_occurrence(type,value,params={})
+    if params[:scope]
+      raise("scope must be an Array") unless params[:scope].is_a?(Array)
+      if (value.is_a? Java::OrgTmapiCore::Locator) || !params[:datatype]
+        return createOccurrence(topic_map.get!(type),value,topic_map.get!(params[:scope]))
+      else # datatype given, no locator
+        return createOccurrence(topic_map.get!(type),value,topic_map.create_locator(params[:datatype]),topic_map.get!(params[:scope]))
+      end
+    else #no scope
+      if (value.is_a? Java::OrgTmapiCore::Locator) || !params[:datatype]
+        return createOccurrence(topic_map.get!(type),value,[].to_java(org.tmapi.core.Topic))
+      else #datatype given, no locator
+        return createOccurrence(topic_map.get!(type),value,topic_map.create_locator(params[:datatype]),[].to_java(org.tmapi.core.Topic))
+      end
+    end
+  end
+
+
+  # Returns the TopicMap the Topic belongs to.
+  #
+  # :call-seq:
+  #   parent -> TopicMap
+  #
+  def parent
+    getParent
+  end
+  alias :reverse_children :parent
+
+  # Calls TMAPI TopicMap.getIndex which
+  # returns the index for the TypeInstanceIndex.
+  # 
+  # :call-seq:
+  #   type_instance_index -> TypeInstanceIndex
+  #
+  def type_instance_index
+    topic_map.type_instance_index
+  end
+
+  superised
+  # Returns the Roles played by this Topic.
+  #
+  # If given, rtype specifies the type of the Roles to be returned;
+  # If given, atype specifies the type of the Association
+  # from which the returned Roles must be part of.
+  # 
+  # rtype and atype may be a Topic/Topic-Reference or Arrays of these types.
+  #
+  # The result may be empty.
+  #
+  # :call-seq:
+  #   roles               -> Array of Roles
+  #   roles(rtype)        -> Array of Roles
+  #   roles(rtype, atype) -> Array of Roles
+  #
+  def roles_played(rtype=:any, atype=:any)
+
+    if rtype == :any # -> atype may only be :any
+      if atype == :any
+        return getRolesPlayed
+      else
+        raise "Associationtype may only be specified if rtype are specified"
+      end
+    end
+
+    # Assume, that rtype is given or set to nil
+    # atype may be :any
+    rtype = topic_map.get(rtype)
+    return Array.new if rtype == nil || (rtype.is_a?(Array) && rtype.include?(nil))
+    #Assume that rtype is given and found
+
+    unless atype == :any
+      atype =  topic_map.get(atype)
+      return Array.new if atype == nil || (atype.is_a?(Array) && atype.include?(nil))
+    end
+    #Assume that if atype is given, it's found
+
+    if rtype.is_a?(Array) #several rtype
+      if atype == :any #no atype
+        return rtype.map{|r| roles_played(r)}.inject(java.util.HashSet.new){|union,element| union.addAll(element); union}
+      elsif atype.is_a?(Array) #several atype
+        return rtype.map{|r| roles_played(r,atype)}.inject(java.util.HashSet.new){|union,element| union.addAll(element); union}
+      else #one associationtype
+        return rtype.map{|r| roles_played(r,atype)}.inject(java.util.HashSet.new){|union,element| union.addAll(element); union}
+      end
+    else #one roletype
+      if atype == :any #no atype
+        return getRolesPlayed(rtype)
+      elsif atype.is_a?(Array) #several atype
+        return atype.map{|a| roles_played(rtype,a)}.inject(java.util.HashSet.new){|union,element| union.addAll(element); union}
+      else #one associationtype
+        return getRolesPlayed(rtype,atype)
+      end
+    end
+  end
+  alias :roles :roles_played
+
+  # Returns the subject identifiers assigned to the current topic.
+  #
+  # :call-seq:
+  #   subject_identifiers -> Set of Locators
+  #
+  def subject_identifiers
+    getSubjectIdentifiers
+  end
+
+  superised
+  # Adds a subject identifier to the current Topic.
+  # Identifier may be a String or Locator.
+  #
+  # :call-seq:
+  #   add_subject_identifier(identifier)
+  #
+  def add_subject_identifier(identifier)
+    if identifier.is_a? Java::OrgTmapiCore::Locator
+      addSubjectIdentifier(identifier)
+    else
+      addSubjectIdentifier(topic_map.create_locator(identifier))
+    end
+  end
+  alias :subject_identifiers= :add_subject_identifier
+
+  superised
+  # Adds a subject locator to the current topic.
+  # Identifier may be a String or Locator.
+  #
+  # :call-seq:
+  #   add_subject_locator(identifier)
+  #
+  def add_subject_locator(identifier)
+    # TODO Spec
+    if identifier.is_a? Java::OrgTmapiCore::Locator
+      addSubjectLocator(identifier)
+    else
+      addSubjectLocator(topic_map.create_locator(identifier))
+    end
+  end
+  alias :subject_locators= :add_subject_locator
+  
+  superised
+  # Removes a subject identifier from the this Topic,
+  # if present.
+  #
+  # Identifier may be a String or Locator.
+  #
+  # :call-seq:
+  #   remove_subject_identifier(identifier)
+  #
+  def remove_subject_identifier(identifier)
+    identifier = topic_map.create_locator(identifier) if identifier.is_a? String 
+    removeSubjectIdentifier(identifier) if identifier.is_a? Java::OrgTmapiCore::Locator
+  end
+
+
+  superised
+  # Removes a subject locator from the this Topic,
+  # if present.
+  #
+  # Identifier may be a String or Locator.
+  #
+  # :call-seq:
+  #   remove_subject_locator(identifier)
+  #
+  def remove_subject_locator(identifier)
+    identifier = topic_map.create_locator(identifier) if identifier.is_a? String 
+    removeSubjectLocator(identifier) if identifier.is_a? Java::OrgTmapiCore::Locator
+  end
+
+  #  superised
+  #  # Removes an item identifer from the this Topic,
+  #  # if present.
+  #  #
+  #  # Identifier may be a String or Locator.
+  #  #
+  #  # :call-seq:
+  #  #   remove_item_identifier(identifier)
+  #  #
+  #  def remove_item_identifier(identifier)
+  #    identifier = topic_map.create_locator(identifier) if identifier.is_a? String
+  #    removeItemIdentifier(identifier) if identifier.is_a? Java::OrgTmapiCore::Locator
+  #  end
+
+  superised
+  # Adds a type given by the identifier to this Topic. 
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   add_type(identifier)   
+  #
+  def add_type(identifier)
+    if identifier.is_a?(Java::OrgTmapiCore::Topic)
+      addType(identifier)
+    elsif identifier.is_a?(Java::OrgTmapiCore::Locator) || identifier.is_a?(String)
+      addType(topic_map.get!(identifier))
+    else
+      raise("Identifier must be a Topic, String or Locator")
+    end
+  end
+
+  # Adds one or several types given by the identifiers.
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   add_types(identifier1, identifier2, ...)
+  #
+  def add_types(*args)
+    args.flatten!
+    args.each do |identifier|
+      add_type(identifier)
+    end
+  end
+
+
+  # Adds an instance given by the identifier to this Topic. 
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   add_instance(identifier)   
+  #
+  def add_instance(identifier)
+    if identifier.is_a?(Java::OrgTmapiCore::Topic)
+      identifier.addType(self)
+    elsif identifier.is_a?(Java::OrgTmapiCore::Locator) || identifier.is_a?(String)
+      topic_map.get!(identifier).addType(self)
+    else
+      raise("Identifier must be a Topic, String or Locator")
+    end
+  end
+
+  # Adds one or several instances given by the identifiers.
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   add_instances(identifier1, identifier2, ...)
+  #
+  def add_instances(*args)
+    args.flatten!
+    args.each do |identifier|
+      add_instance(identifier)
+    end
+  end
+
+  # Returns the reifiable Construct which is reified by this Topic
+  # or nil if this Topic does not reify a statement.
+  #
+  # :call-seq:
+  #   reifier -> Name, Occurrence, Variant, Association, Role or TopicMap
+  #
+  def reified
+    getReified
+  end
+  
+  # Sets this Topic as reifier of the reifiable Construct, given by the
+  # identifier.
+  #
+  # Identifier may be a Name, Variant, Occurrence, Association, Role or
+  # TopicMap.
+  #
+  # :call-seq:
+  #   reified = identifier
+  #
+  def reified=(identifier)
+    if identifier.is_a?(Java::OrgTmapiCore::Reifiable)
+      identifier.reifier = self 
+      return
+    end
+    raise("reified=: Identifier may be a Name, Variant, Occurrence, Association, Role or TopicMap")
+  end
+
+  superised
+  # Removes a type given by the identifier from this Topic,
+  # if present.
+  #
+  # Identifier may be a Topic or Topic-Reference.
+  #
+  # :call-seq:
+  #   remove_type(identifier)
+  #
+  def remove_type(identifier)
+    if identifier.is_a? Java::OrgTmapiCore::Topic
+      removeType(identifier)
+    else
+      identifier = topic_map.get(identifier)
+      removeType(identifier) if identifier
+    end
+  end
+
+
+  # TODO extend this, maybe allow for a removal of any topic no matter how important
+  # it may be for the whole topic map
+  def force_remove
+    self.roles_played.to_a.clone.each{|p| p.parent.remove}
+    self.remove
+  end
+
+end
+
+
+