udat 1.0.0 → 1.1.0

data/lib/udat.rb

@@ -125,9 +125,13 @@ class Udat
 
   # Returns an escaped version of a string, where backslashes are preceding
   # certain reserved characters.
-  def escape_string(string)
+  def self.escape_string(string)
     string.to_s.gsub /([<>\[\]|\\])/, "\\\\\\1"
   end
+  # Calls Udat.escape_string.
+  def escape_string(string)
+    self.class.escape_string(string)
+  end
   private :escape_string
 
   # Tag (i.e. type of the content).
@@ -179,13 +183,14 @@ class Udat
   def hash
     to_s.hash
   end
-  # Returns true, if class, tag and content are matching another object.
+  # Returns true, if class, tag and content (including it's order in case
+  # of a UdatCollection) are matching another object.
   def eql?(other)
     self.class == other.class and
       self.tag == other.tag and
       self.to_s == other.to_s
   end
-  # Same as Udat#eql?.
+  # Same as Udat#eql?, but behaves differently in UdatCollection.
   def ==(other)
     self.eql? other
   end
@@ -325,6 +330,56 @@ end
 # methods of this class to Udat objects using Object#to_udat.
 class UdatCollection < Udat
 
+  # Internally used wrapper class for Udat objects, to lookup
+  # UdatCollection's in Hash'es, while ignoring the order of their content.
+  class UdatUnorderedWrapper
+    def initialize(content)
+      @content = content
+    end
+    attr_accessor :content
+    def hash
+      if content.kind_of? UdatCollection
+        hash = 0
+        content.key_value_pairs.each do |key, value|
+          hash += key.hash
+          hash += value.hash
+        end
+        return hash
+      else
+        return content.hash
+      end
+    end
+    def eql?(other)
+      return false unless self.class == other.class
+      if self.content.class == other.content.class and
+          self.content.tag == other.content.tag
+        if self.content.kind_of? UdatCollection
+          own_pairs = self.content.key_value_pairs
+          other_pairs = other.content.key_value_pairs
+          own_pairs.each do |own_pair|
+            catch :found do
+              other_pairs.each_index do |index|
+                if own_pair.eql? other_pairs[index]
+                  other_pairs.delete_at index
+                  throw :found
+                end
+              end
+              return false
+            end
+          end
+          return true
+        else
+          return self.content.eql?(other.content)
+        end
+      else
+        return false
+      end
+    end
+    def ==(other)
+      self.eql? other
+    end
+  end
+
   public_class_method :new
   # Creates a new Udat object with a given tag (which may be nil) and a
   # given content, represented by a nested Array structure. See the source
@@ -333,7 +388,8 @@ class UdatCollection < Udat
   def initialize(tag, content)
     super tag
     @ordered = true
-    clear
+    @entries = []
+    require_index_hashes
     unless content.nil?
       if content.respond_to? :to_ary
         content = content.to_ary
@@ -345,51 +401,97 @@ class UdatCollection < Udat
   end
 
   # Deletes the internal index hashes.
-  def index_void!
+  # They are automatically reconstructed once a lookup is done.
+  # This method should be called by the user, if contained Udat objects
+  # have changed, AFTER being added to this collection (similar to
+  # Hash#rehash).
+  def rehash
     synchronize do
-      @key_to_value = nil
-      @value_to_key = nil
+      @key_indicies = nil
+      @value_indicies = nil
+      @unordered_key_indicies = nil
+      @unordered_value_indicies = nil
+      @all_unordered_key_indicies = nil
+      @all_unordered_value_indicies = nil
     end
     return self
   end
-  # Checks, if the internal index hashes are existent
-  # (and therefore up to date).
-  def index_void?
+
+  # Returns true, if the internal index hashes are not existent.
+  def index_hashes_void?
     synchronize do
-      return @key_to_value.nil?
-    end
+      return @key_indicies.nil?
+    end
+  end
+  private :index_hashes_void?
+  # Registers a key value pair in the index.
+  def add_to_index_hashes(index, key, value)
+    @key_indicies[key] ||= []
+    @key_indicies[key] << index
+    @value_indicies[value] ||= []
+    @value_indicies[value] << index
+    if key.kind_of? UdatCollection and key.unordered?
+      @unordered_key_indicies[UdatUnorderedWrapper.new(key)] ||= []
+      @unordered_key_indicies[UdatUnorderedWrapper.new(key)] << index
+    end
+    if value.kind_of? UdatCollection and value.unordered?
+      @unordered_value_indicies[UdatUnorderedWrapper.new(value)] ||= []
+      @unordered_value_indicies[UdatUnorderedWrapper.new(value)] << index
+    end
+    @all_unordered_key_indicies[UdatUnorderedWrapper.new(key)] ||= []
+    @all_unordered_key_indicies[UdatUnorderedWrapper.new(key)] << index
+    @all_unordered_value_indicies[UdatUnorderedWrapper.new(value)] ||= []
+    @all_unordered_value_indicies[UdatUnorderedWrapper.new(value)] << index
+    return self
   end
+  private :add_to_index_hashes
   # Creates index hashes, if they are not existent.
-  def require_index
+  def require_index_hashes
     synchronize do
-      if index_void?
-        @key_to_value = {}
-        @value_to_key = {}
-        @entries.each do |key, value|
-          unless key.nil?
-            @key_to_value[key] = value unless @key_to_value.has_key? key
-            @value_to_key[value] = key unless @value_to_key.has_key? value
-          end
+      if index_hashes_void?
+        @key_indicies = {}
+        @value_indicies = {}
+        @unordered_key_indicies = {}
+        @unordered_value_indicies = {}
+        @all_unordered_key_indicies = {}
+        @all_unordered_value_indicies = {}
+        @entries.each_index do |index|
+          key_value_pair = @entries[index]
+          key = key_value_pair[0]
+          value = key_value_pair[1]
+          add_to_index_hashes(index, key, value) unless key.nil?
         end
       end
     end
     return self
   end
-  private :index_void!, :index_void?, :require_index
+  private :require_index_hashes
 
   # Empties the collection.
   def clear
-    @entries = []
-    @key_to_value = {}
-    @value_to_key = {}
+    synchronize do
+      @entries.clear
+      rehash
+      require_index_hashes
+    end
     return self
   end
+  # Deletes the entry at the given numeric index.
+  # Returns the value, or nil if the index is out of bounds.
+  def delete_at(index)
+    index = index.to_int
+    synchronize do
+      key_value_pair = @entries.delete_at(index)
+      rehash
+      return key_value_pair ? key_value_pair[0] : nil
+    end
+  end
   # Deletes all entries with a given key.
   def delete_key(key)
     key = key.to_udat
     synchronize do
       @entries.delete_if { |e_key, e_value| e_key == key }
-      index_void!
+      rehash
     end
     return self
   end
@@ -398,7 +500,7 @@ class UdatCollection < Udat
     value = value.to_udat
     synchronize do
       @entries.delete_if { |e_key, e_value| e_value == value }
-      index_void!
+      rehash
     end
     return self
   end
@@ -408,11 +510,9 @@ class UdatCollection < Udat
     key = key.to_udat
     value = value.to_udat
     synchronize do
+      index = @entries.length
       @entries << [key, value]
-      unless index_void?
-        @key_to_value[key] = value unless @key_to_value.has_key? key
-        @value_to_key[value] = key unless @value_to_key.has_key? value
-      end
+      add_to_index_hashes(index, key, value) unless index_hashes_void?
     end
     return self
   end
@@ -450,7 +550,7 @@ class UdatCollection < Udat
       value = value.to_ary
       unless value.length == 2
         raise ArgumentError,
-          "#{value.length} array elements found, while 2 were expected."
+          "#{value.length} array elements found where 2 were expected."
       end
       return append_pair(value[0], value[1])
     else
@@ -480,20 +580,52 @@ class UdatCollection < Udat
       return entry ? entry[1] : nil
     end
   end
-  # Returns the first value having a given key.
-  def value_by_key(key)
+  # Returns an Array of values having a given key.
+  def values_by_key(key)
+    key = key.to_udat
     synchronize do
-      require_index
-      return @key_to_value[key.to_udat]
+      require_index_hashes
+      if key.kind_of? UdatCollection and key.unordered?
+        indicies = @all_unordered_key_indicies[
+          UdatUnorderedWrapper.new(key)
+        ] || []
+      else
+        indicies = (@key_indicies[key] || []) + (
+          @unordered_key_indicies[UdatUnorderedWrapper.new(key)] || []
+        )
+        indicies.uniq!
+        indicies.sort!
+      end
+      return indicies.collect { |index| @entries[index][1] }
     end
   end
-  # Returns the first key having a given value.
-  def key_by_value(value)
+  # Returns an Array of keys having a given value.
+  def keys_by_value(value)
+    value = value.to_udat
     synchronize do
-      require_index
-      @value_to_key[value.to_udat]
+      require_index_hashes
+      if value.kind_of? UdatCollection and value.unordered?
+        indicies = @all_unordered_value_indicies[
+          UdatUnorderedWrapper.new(value)
+        ] || []
+      else
+        indicies = (value_indicies[key] || []) + (
+          @unordered_value_indicies[UdatUnorderedWrapper.new(value)] || []
+        )
+        indicies.uniq!
+        indicies.sort!
+      end
+      return indicies.collect { |index| @entries[index][0] }
     end
   end
+  # Returns the last value having a given key.
+  def value_by_key(key)
+    values_by_key(key).last
+  end
+  # Returns the last key having a given value.
+  def key_by_value(value)
+    keys_by_value(value).last
+  end
 
   # Behaves differently depending on the type of the argument.
   # If the argument is an Integer the method behaves same as
@@ -675,7 +807,6 @@ class UdatCollection < Udat
   # ignored for comparisons.
   def ordered=(ordered)
     synchronize do
-      index_void!
       if ordered == false
         @ordered = false
       else
@@ -704,40 +835,13 @@ class UdatCollection < Udat
     end
   end
 
-  # Returns a hash key used by ruby's Hash'es.
-  def hash
-    hash = 0
-    @entries.each do |key, value|
-      hash += key.hash
-      hash += value.hash
-    end
-    return hash
-  end
-  # Returns true, if class, tag and content are matching another object.
-  # The order of the content is ignored, if this or the other object has
-  # the 'ordered' attribute set to false.
-  def eql?(other)
-    if self.class == other.class and self.tag == other.tag
-      if self.ordered? and other.ordered?
-        return self.to_s == other.to_s
-      else
-        own_pairs = self.key_value_pairs
-        other_pairs = other.key_value_pairs
-        own_pairs.each do |own_pair|
-          catch :found do
-            other_pairs.each_index do |index|
-              if own_pair.eql? other_pairs[index]
-                other_pairs.delete_at index
-                throw :found
-              end
-            end
-            return false
-          end
-        end
-        return true
-      end
+  def ==(other)
+    return false unless self.class == other.class
+    if self.unordered? or other.unordered?
+      return UdatUnorderedWrapper.new(self) ==
+        UdatUnorderedWrapper.new(other)
     else
-      return false
+      return super
     end
   end
 
@@ -758,6 +862,7 @@ class UdatScalar < Udat
 
   # Content of the scalar (a String).
   attr_reader :content
+  # Sets the content. The content is casted to a string.
   def content=(content)
     @content = content.to_s
   end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: udat
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2007-05-22 00:00:00 +00:00
+  version: 1.1.0
+date: 2007-05-23 00:00:00 +00:00
 summary: Parser and generator for UDAT documents, a generic data format similar to XML or YAML.
 require_paths: 
 - lib/