rtm-javatmapi 0.3.1-java

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

@@ -0,0 +1,38 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Java::OrgTmapiCore::Reifiable
+
+  include RTM::Reifiable
+  extend Superiseable
+
+  # Returns the reifier (a topic) of this Reifiable
+  # or nil if the Reifiable is not reified.
+  #
+  # :call-seq:
+  #   reifier -> Topic
+  #
+  def reifier
+    getReifier
+  end
+
+  superised
+  # Sets the reifier of this reifiable Construct.
+  # The specified reifier MUST NOT reify another information item.
+  #
+  # Identifier may be a topic reference or nil,
+  # if an existing reifier should be removed.
+  #
+  # :call-seq:
+  #   reifier = identifier
+  #   reifier = ()
+  #
+  def reifier=(identifier=nil)
+    unless identifier
+      setReifier(nil)
+      return
+    end
+    raise("reifier=: identifier muss be a Topic, Locator or String; not given or nil") unless identifier.is_a?(Java::OrgTmapiCore::Topic) || identifier.is_a?(Java::OrgTmapiCore::Locator) || identifier.is_a?(String)
+    setReifier(topic_map.get!(identifier))
+  end
+end

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

@@ -0,0 +1,49 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Java::OrgTmapiCore::Role
+
+  include RTM::Role
+  extend Superiseable
+
+  # Returns the Association to which this Role belongs.
+  #
+  # :call-seq:
+  #   parent -> Association
+  #
+  def parent
+		getParent
+	end
+  alias :reverse_children :parent
+
+  # Returns the Topic playing the current Role.
+  #
+  # :call-seq:
+  #   player -> Topic
+  #
+	def player
+		getPlayer
+	end
+
+  superised
+  # Sets the role player. Any previous role player will be overriden.
+  #
+  # Identifier may be a topic reference.
+  #
+  # :call-seq:
+  #   player=(identifier)
+  #
+	def player=(identifier)
+		setPlayer(topic_map.get!(identifier))
+	end
+  
+  # Returns the identifier of the current Role.
+  # This property has no representation in the Topic Maps - Data Model.
+  #
+  # :call-seq:
+  #   id -> String
+  #
+  def id
+    getId
+  end
+end

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

@@ -0,0 +1,93 @@
+# Copyright: Copyright 2009 Topic Maps Lab, University of Leipzig.
+# License:   Apache License, Version 2.0
+
+module Java::OrgTmapiCore::Scoped
+
+  include RTM::Scoped
+  extend Superiseable
+
+  # 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 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 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 reference.
+  #
+  # :call-seq:
+  #   remove_theme(identifier)
+  #
+	def remove_theme(identifier)
+    identifier = topic_map.get(identifier)
+    removeTheme(identifier) if identifier.is_a?(Java::OrgTmapiCore::Topic)
+	end
+
+  # Removes one or several topics from the scope.
+  #
+  # An identifier may be a topic reference.
+  #
+  # :call-seq:
+  #   remove_themes(identifier)
+  #   remove_themes(identifier1, identifier2, ...)
+  #
+	def remove_themes(*args)
+    args.flatten.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,504 @@
+# 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 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 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 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,new_empty_java_topic_array)
+    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,new_empty_java_topic_array) : 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,new_empty_java_topic_array)
+      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 reference.
+  #
+  # 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 topic reference. 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={})
+    # creating a topic for the type
+    type = topic_map.get!(type)
+    # reading the datatype if given. nil otherwise
+    datatype = params[:datatype]
+    # reading value and setting datatype if not done before
+    unless datatype
+      if value.is_a?(Java::OrgTmapiCore::Locator)
+        datatype = RTM::PSI[:IRI]
+      elsif value.is_a?(String)
+        datatype = RTM::PSI[:String]
+      elsif value.is_a?(Float)
+        datatype = RTM::PSI[:Float]
+      elsif value.is_a?(Fixnum)
+        datatype = RTM::PSI[:Long]
+      elsif value.is_a?(Bignum)
+        datatype = RTM::PSI[:Integer]
+      elsif value.is_a?(DateTime) #DateTime is a Time and a Date
+        datatype ||= RTM::PSI[:DateTime]
+      elsif value.is_a?(Time)
+        datatype ||= RTM::PSI[:Time]
+      elsif value.is_a?(Date)
+        datatype ||= RTM::PSI[:Date]
+      else
+        raise NoDatatypeHandlerAvailableException.new(value)
+      end
+    end
+    # creating locator for datatype
+    datatype = topic_map.create_locator(datatype)
+    # value must be a String
+    value = value.to_s
+    # if datatype is xsd:anyURI -> resolve value against base_iri
+    if datatype.reference == RTM::PSI[:IRI]
+      value = topic_map.create_locator(value).reference
+    end
+
+    begin
+      if params[:scope]
+        raise("scope must be an Array") unless params[:scope].is_a?(Array)
+
+        return createOccurrence(type, value, datatype, topic_map.get!(params[:scope]))
+
+      else #no scope
+        return createOccurrence(type, value, datatype, new_empty_java_topic_array)
+      end
+    rescue java.lang.IllegalArgumentException => iae
+      raise(iae.message)
+    end
+  end
+
+  # Returns the TopicMap the Topic belongs to.
+  #
+  # :call-seq:
+  #   parent -> TopicMap
+  #
+  def parent
+    getParent
+  end
+  alias :reverse_children :parent
+
+  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 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)
+    begin
+      if identifier.is_a? Java::OrgTmapiCore::Locator
+        addSubjectIdentifier(identifier)
+      else
+        addSubjectIdentifier(topic_map.create_locator(identifier))
+      end
+    rescue Java::OrgTmapiCore::IdentityConstraintException => ice
+      # TODO add condition to switch off automerge
+      self.mergeIn(self.topic_map.get(identifier))
+    end
+  end
+
+  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
+
+  # Returns the subject locators assigned to the current topic.
+  #
+  # :call-seq:
+  #   subject_locators -> Set of Locators
+  #
+  def subject_locators
+    getSubjectLocators
+  end
+
+  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
+    begin
+      if identifier.is_a? Java::OrgTmapiCore::Locator
+        addSubjectLocator(identifier)
+      else
+        addSubjectLocator(topic_map.create_locator(identifier))
+      end
+    rescue Java::OrgTmapiCore::IdentityConstraintException => ice
+      # TODO add condition to switch off automerge
+      self.mergeIn(self.topic_map.topic_by_subject_locator(identifier))
+    end
+  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 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 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 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 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 of this topic,
+  # if present.
+  #
+  # Identifier may be a topic reference.
+  #
+  # :call-seq:
+  #   remove_type(identifier)
+  #
+  def remove_type(identifier)
+    identifier = topic_map.get(identifier)
+    removeType(identifier) if identifier
+  end
+
+  # Removes an instance given by the identifier of this topic,
+  # if present.
+  #
+  # Identifier may be a topic reference.
+  #
+  # :call-seq:
+  #   remove_instance(identifier)
+  #
+  def remove_instance(identifier)
+    identifier = topic_map.get(identifier)
+    return unless identifier
+    identifier.removeType(self)
+  end
+
+  private
+  def new_empty_java_topic_array
+    [].to_java(Java::OrgTmapiCore::Topic)
+  end
+
+  class NoDatatypeHandlerAvailableException < Exception
+    def initialize(value)
+      super "Cannot map #{value} to an occurrence value+datatype. Maybe you need to add a handler for your Ruby object type."
+    end
+  end
+end
+
+
+