hashtable 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5852fb24336d190f81a89d83eb6b23184f37972507641ac2e0b78c323a3ef65
-  data.tar.gz: a809dbacc1536fd55d18e30d677aba9fdbe331cdda5f2612942a394fa7bad5f7
+  metadata.gz: 9a2d080d4eda5fb41e97c4661131fe7b3124530d4cb3604e907ca1294b38fe20
+  data.tar.gz: 456c01089c6b9764016386137ef4be6ac247fbef83921861d803659c798d9dec
 SHA512:
-  metadata.gz: 044d20bcefe08d1c84d7a7fec897fc4d2f892b5a29c28e8f373ddb804039fc0679f9bb1b52992415e3c9cf8f0d62adf39ba42bd4deee7181422062b97916e01f
-  data.tar.gz: 47d1688da243dd2b5377f880bee64e7b91709b7b1efd0ff252d8a85849f5b5bfe155f68ffe780e8a87689e96e379849001c4757727a977d4b809faecb6cdd700
+  metadata.gz: 89feb259b63fc1795ff796a0cc434dfe78108aad338a756be4e331034103c2ca3096f617130e4d1d85a24ec7921a7f8d118a08e512b3eae9cd7b4cef8728e690
+  data.tar.gz: a442d8711dcfa1db95600bd48166e35b12f5612f3b94fbe80d08b10a3ea00aaff49002e0f238eaa1273b456a170f9ee8722b9eb79b03934d686271c71ff32274

data/README.md

@@ -52,116 +52,57 @@ end
 Store numbers：
 
 ```ruby
-class Traits
-  def hash_lookup_key(key)
-    key
-  end
-
-  def lookup_key_to_storage_key(key)
-    key
-  end
-
-  def storage_key_to_lookup_key(key)
-    key
-  end
-end
-
 table = HashTable::HashTable.new(2)
-traits = Traits.new
-table.set(3, 7, )
-table.set(4, 5, traits)
-table.set(5, 6, traits)
-table.set(6, 7, traits)
-table.set(8, 9, traits)
-table.set(9, 19, traits)
+table.set(3, 7, HashTable::IdentityHashTraits.new)
+table.set(4, 5, HashTable::IdentityHashTraits.new)
+table.set(5, 6, HashTable::IdentityHashTraits.new)
+table.set(6, 7, HashTable::IdentityHashTraits.new)
+table.set(8, 9, HashTable::IdentityHashTraits.new)
+table.set(9, 19, HashTable::IdentityHashTraits.new)
+expect(table.size).to eq(6)
+expect(table.get(3, HashTable::IdentityHashTraits.new)).to eq(7)
+expect(table.get(4, HashTable::IdentityHashTraits.new)).to eq(5)
+expect(table.get(5, HashTable::IdentityHashTraits.new)).to eq(6)
+expect(table.get(6, HashTable::IdentityHashTraits.new)).to eq(7)
+expect(table.get(8, HashTable::IdentityHashTraits.new)).to eq(9)
+expect(table.get(9, HashTable::IdentityHashTraits.new)).to eq(19)
+expect(table.capacity).to eq(16)
 ```
 
 Store strings：
 
 ```ruby
-class StringTraits
-  attr_reader :string_table, :string_index
-
-  def initialize
-    @string_table = "\0"
-    @string_index = 1
-  end
-
-  def hash_lookup_key(key)
-    result = 0
-    key.each_byte { |byte| result += byte * 13 }
-    result
-  end
-
-  def lookup_key_to_storage_key(key)
-    @string_table += "#{key}\0"
-    old_si = @string_index
-    @string_index += key.length + 1
-    old_si
-  end
-
-  def storage_key_to_lookup_key(offset)
-    @string_table[offset..-1][/[^\0]+/]
-  end
-end
-
-
 table = HashTable::HashTable.new(2)
-traits = StringTraits.new
+traits = HashTable::StringIdentityHashTraits.new
 table.set('ViewController64.h', 'ViewController64.h', traits)
 table.set('ViewController65.h', 'ViewController65.h', traits)
 table.set('ViewController66.h', 'ViewController66.h', traits)
 table.set('ViewController67.h', 'ViewController67.h', traits)
 table.set('ViewController68.h', 'ViewController68.h', traits)
 table.set('ViewController69.h', 'ViewController69.h', traits)
-# ViewController64.h
-table.get('ViewController64.h', traits)
-# \u0000ViewController64.h\u0000ViewController65.h\u0000ViewController66.h\u0000ViewController67.h\u0000ViewController68.h\u0000ViewController69.h\u0000
-p traits.string_table
+expect(table.size).to eq(6)
+expect(table.get('ViewController64.h', traits)).to eq('ViewController64.h')
+expect(table.get('ViewController65.h', traits)).to eq('ViewController65.h')
+expect(table.get('ViewController66.h', traits)).to eq('ViewController66.h')
+expect(table.get('ViewController67.h', traits)).to eq('ViewController67.h')
+expect(table.get('ViewController68.h', traits)).to eq('ViewController68.h')
+expect(table.get('ViewController69.h', traits)).to eq('ViewController69.h')
+expect(table.capacity).to eq(16)
+expect(traits.string_table).to eq("\u0000ViewController64.h\u0000ViewController65.h\u0000ViewController66.h\u0000ViewController67.h\u0000ViewController68.h\u0000ViewController69.h\u0000")
 ```
 
 Store just key string：
 
 ```ruby
-class StringTraits
-  attr_reader :string_table, :string_index
-
-  def initialize
-    @string_table = "\0"
-    @string_index = 1
-  end
-
-  def hash_lookup_key(key)
-    result = 0
-    key.each_byte { |byte| result += byte * 13 }
-    result
-  end
-
-  def lookup_key_to_storage_key(key)
-    @string_table += "#{key}\0"
-    old_si = @string_index
-    @string_index += key.length + 1
-    old_si
-  end
-
-  def storage_key_to_lookup_key(offset)
-    @string_table[offset..-1][/[^\0]+/]
-  end
-end
-
-
-table = HashTable::HashTable.new(2)
-traits = StringTraits.new
-
+table = HashTable::HashTable.new
+traits = HashTable::StringIdentityHashTraits.new
 (0..31).each do |i|
-   table.add("ViewController#{i}.h", traits)
+  table.add("ViewController#{i}.h", traits)
 end
-# 32
-p table.size
-# 64
-p table.capacity
-# 32
-p table.num_entries
+p "#{table.size}---#{table.capacity}----#{table.num_entries}"
+expect(table.size).to eq(32)
+expect(table.capacity).to eq(64)
+expect(table.num_entries).to eq(32)
 ```
 
 Store strings and expand capacity:
@@ -171,44 +112,16 @@ Store strings and expand capacity:
 - capacity is power_of_two
 
 ```ruby
-class StringTraits
-  attr_reader :string_table, :string_index
-
-  def initialize
-    @string_table = "\0"
-    @string_index = 1
-  end
-
-  def hash_lookup_key(key)
-    result = 0
-    key.each_byte { |byte| result += byte * 13 }
-    result
-  end
-
-  def lookup_key_to_storage_key(key)
-    @string_table += "#{key}\0"
-    old_si = @string_index
-    @string_index += key.length + 1
-    old_si
-  end
-
-  def storage_key_to_lookup_key(offset)
-    @string_table[offset..-1][/[^\0]+/]
-  end
-end
-
-table = HashTable::HashTable.new(8192, expand: true)
-traits = StringTraits.new
+table = HashTable::HashTable.new(1364, expand: true)
+traits = HashTable::StringHashTraits.new
 buckets = (0..1363).map do |i|
-    a = ["ViewController#{i}.h", "/Users/ws/Desktop/llvm/TestAndTestApp/TestAndTestApp/Group/h2/#{i}", "ViewController#{i}.h"]
-    table.adds(a, traits)
+table.set("ViewController#{i}.h",
+            ["/Users/ws/Desktop/llvm/TestAndTestApp/TestAndTestApp/Group/h2/#{i}", "ViewController#{i}.h"], traits)
 end
-# 2728
-p table.size
-# 8192
-p table.capacity
-# 5461
-p table.num_entries
+p "#{table.size}---#{table.capacity}----#{table.num_entries}"
+expect(table.size).to eq(1364)
+expect(table.capacity).to eq(8192)
+expect(table.num_entries).to eq(4097)
 ```
 
 ## Contributing

data/lib/hashtable/hash_table.rb

@@ -1,24 +1,91 @@
 # frozen_string_literal: true
 
+require 'benchmark'
+
 # module HashTable
 module HashTable
+
+  EXPAND_KEY_COUNT_CONST = {
+    8 => [0, 0],
+    16 => [6, 9],
+    32 => [8, 17],
+    64 => [13, 33],
+    128 => [23, 65],
+    256 => [44, 129],
+    512 => [86, 257],
+    1024 => [171, 513],
+    2048 => [341, 1025],
+    4096 => [682, 2049],
+    8192 => [1364, 4097],
+    16_384 => [2729, 8193],
+    32_768 => [5459, 16_385],
+    65_536 => [10_920, 32_769],
+    131_072 => [21_842, 65_537],
+    262_144 => [43_687, 131_073],
+    524_288 => [87_377, 262_145],
+    1_048_576 => [174_758, 524_289],
+    2_097_152 => [349_520, 1_048_577],
+    4_194_304 => [699_045, 2_097_153],
+    8_388_608 => [1_398_095, 4_194_305],
+    16_777_216 => [2_796_196, 8_388_609],
+    33_554_432 => [5_592_398, 16_777_217],
+    67_108_864 => [11_184_803, 33_554_433],
+    134_217_728 => [22_369_613, 67_108_865],
+    268_435_456 => [44_739_234, 134_217_729],
+    536_870_912 => [89_478_476, 268_435_457],
+    1_073_741_824 => [178_956_961, 536_870_913],
+    2_147_483_648 => [357_913_931, 1_073_741_825],
+    4_294_967_296 => [715_827_872, 2_147_483_649],
+    8_589_934_592 => [1_431_655_754, 4_294_967_297],
+    17_179_869_184 => [2_863_311_519, 8_589_934_593],
+    34_359_738_368 => [5_726_623_049, 17_179_869_185],
+    68_719_476_736 => [11_453_246_110, 34_359_738_369],
+    137_438_953_472 => [22_906_492_232, 68_719_476_737],
+    274_877_906_944 => [45_812_984_477, 137_438_953_473],
+    549_755_813_888 => [91_625_968_967, 274_877_906_945],
+    1_099_511_627_776 => [183_251_937_948, 549_755_813_889]
+  }.freeze
   # HashTable
   # @abstract
   class HashTable
-    # @return [Integer] nums of HashTable entries
-    attr_reader :num_entries
+    attr_reader :size
+
+    # @return [HashTable]
+    # @param  [object] p_value placeholder value with @buckets_v
+    # @param  [Bool] Does it need to be expanded
+    def self.new_from_vlaue_placeholder(count = 0, p_value = nil, expand: false)
+      new(count, p_value: p_value, expand: expand)
+    end
 
-    def initialize(capacity = 8, expand: false)
-      capacity = capacity < 8 ? 8 : 2**(capacity - 1).bit_length
-      @buckets = Array.new(capacity)
+    # @return [HashTable]
+    # @param  [Integer] count of entries
+    # @param  [object] p_key placeholder key with @buckets_k
+    # @param  [object] p_value placeholder value with @buckets_v
+    # @param  [Bool] Does it need to be expanded
+    def initialize(count = 0, p_key: nil, p_value: nil, expand: false)
+      capacity = calculate_count(count, expand: expand)
+      @buckets_k = Array.new(capacity, p_key)
+      @buckets_v = Array.new(capacity, p_value)
       @present = SparseBitArray.new
       @deleted = SparseBitArray.new
       @expand = expand
-      @num_entries = 0
+      @size = 0
     end
 
-    def size
-      @present.count
+    def num_entries
+      raise 'count must less than 2_863_311_519' if size > 2_863_311_519
+      return size unless @expand
+
+      es = EXPAND_KEY_COUNT_CONST[capacity]
+      size - es[0] + es[1]
+    end
+
+    def keys
+      @buckets_k
+    end
+
+    def values
+      @buckets_v
     end
 
     def empty?
@@ -26,36 +93,27 @@ module HashTable
     end
 
     def capacity
-      @buckets.length
+      @buckets_k.length
     end
 
     # @return [Integer] Find the entry whose key has the specified hash value,
     # using the specified traits defining hash function and equality.
     # @param  [object] key
     # @param  [object] traits
-    def find(key, traits)
-      raise ArgumentError, 'traits must respond to hash_lookup_key method' unless traits.respond_to?(:hash_lookup_key)
-
-      unless traits.respond_to?(:storage_key_to_lookup_key)
-        raise ArgumentError,
-              'traits must respond to storage_key_to_lookup_key method'
-      end
-      h = traits.hash_lookup_key(key) % capacity
+    def find(key, traits = IdentityHashTraits.new)
+      nums = capacity - 1
+      h = traits.hash_lookup_key(key) & nums
       i = h
-      fisrt_unsed = nil
       loop do
-        if present?(i)
-          return i if !@buckets[i].nil? && traits.storage_key_to_lookup_key(@buckets[i].first) == key
-        else
-          fisrt_unsed = i if fisrt_unsed.nil?
-          break unless deleted?(i)
-        end
-        i = (i + 1) % capacity
+        bucket = @buckets_k[i]
+        return i if !bucket.nil? && present?(i) && traits.storage_key_to_lookup_key(bucket) == key
+
+        break unless deleted?(i)
+
+        i = (i + 1) & nums
         break if i == h
       end
-      raise ArgumentError if fisrt_unsed.nil?
-
-      fisrt_unsed
+      i
     end
 
     # @return [Integer] internal key
@@ -63,23 +121,20 @@ module HashTable
     # @param  [object] key
     # @param  [object] value
     # @param  [object] traits
-    def set(key, value, traits)
+    def set(key, value, traits = IdentityHashTraits.new)
       set_as_interal(key, traits, value)
     end
 
-    def get(key, traits)
+    def get(key, traits = IdentityHashTraits.new)
       i = find(key, traits)
-      bucket = @buckets[i]
-      raise ArgumentError if bucket.nil? || bucket.empty?
-
-      bucket.last
+      @buckets_v[i]
     end
 
     # @return [Integer] internal key
     # Set the entry using a key type that the specified Traits can convert from a real key to an internal key.
     # @param  [object] key
     # @param  [object] traits
-    def add(key, traits)
+    def add(key, traits = IdentityHashTraits.new)
       set_as_interal(key, traits)
     end
 
@@ -87,13 +142,13 @@ module HashTable
     # Set the entry using a key type that the specified Traits can convert from a real key to an internal key.
     # @param  [object] key
     # @param  [object] traits
-    def adds(keys, traits)
+    def adds(keys, traits = IdentityHashTraits.new)
       keys.map { |key| set_as_interal(key, traits) }
     end
 
     protected
 
-    attr_reader :present, :deleted, :buckets
+    attr_reader :present, :deleted, :buckets_k, :buckets_v
 
     def present?(key)
       @present.test?(key)
@@ -109,62 +164,61 @@ module HashTable
     # @param  [object] traits
     # @param  [object] value
     # @param  [object] internal_key
-    def set_as_interal(key, traits, value = nil, internal_key = nil)
-      unless traits.respond_to?(:lookup_key_to_storage_key)
-        raise ArgumentError,
-              'traits must respond to lookup_key_to_storage_key method'
-      end
-      unless traits.respond_to?(:storage_key_to_lookup_key)
-        raise ArgumentError,
-              'traits must respond to storage_key_to_lookup_key method'
-      end
-
+    def set_as_interal(key, traits = IdentityHashTraits.new, value = nil, internal_key = nil)
       index = find(key, traits)
-      bucket = @buckets[index] ||= []
-      if bucket.empty?
+      bucket_k = @buckets_k[index]
+      if bucket_k.nil?
         raise ArgumentError if present?(index)
 
-        bucket[0] = internal_key.nil? ? traits.lookup_key_to_storage_key(key) : internal_key
-        bucket[1] = value unless value.nil?
+        @buckets_k[index] = bucket_k = internal_key.nil? ? traits.lookup_key_to_storage_key(key) : internal_key
+        @buckets_v[index] = traits.lookup_key_to_storage_value(bucket_k, value)
         @present.set(index)
         @deleted.reset(index)
+        @size += 1
         grow(traits)
       else
-        raise ArgumentError unless present?(index)
-        raise ArgumentError unless traits.storage_key_to_lookup_key(@buckets[index].first) == key
+        raise ArgumentError unless present?(index) || traits.storage_key_to_lookup_key(bucket_k) == key
 
-        bucket[1] = value unless value.nil?
+        @buckets_v[index] = traits.lookup_key_to_storage_value(bucket_k, value)
       end
-      return index if traits.respond_to?(:lookup_key_and_value)
-
-      bucket[0]
+      bucket_k
     end
 
     private
 
-    def grow(traits)
-      unless traits.respond_to?(:storage_key_to_lookup_key)
-        raise ArgumentError,
-              'traits must respond to storage_key_to_lookup_key method'
+    def need_grow(size, count, expand: false)
+      raise 'count must less than 2_863_311_519' if count > 2_863_311_519
+
+      count *= 2
+      return size >= count / 3 + 1 unless expand
+
+      size >= EXPAND_KEY_COUNT_CONST[count][0]
+    end
+
+    def calculate_count(size, expand: false)
+      return 8 if size < 6
+      raise 'count must less than 2_863_311_519' if size > 2_863_311_519
+
+      if expand
+        EXPAND_KEY_COUNT_CONST.each_pair { |key, e| return key / 2 if size < e[0] }
+      else
+        2**(size * 3 / 2 + 1 - 1).bit_length
       end
-      @num_entries += 1
-      n = 2**(@num_entries - 1).bit_length
-      m = n < 8 ? 8 : n
-      max_load = m * 2 / 3 + 1
-      entries = @expand ? num_entries : size
-      return if entries < max_load
-
-      @num_entries = m + 1 if @expand
-      new_capacity = m * 2
-      return if new_capacity <= capacity
-
-      new_map = HashTable.new(new_capacity, expand: @expand)
+    end
+
+    def grow(traits = IdentityHashTraits.new)
+      return unless need_grow(size, capacity, expand: @expand)
+
+      new_map = HashTable.new(size, expand: @expand)
       @present.each do |i|
-        lookup_key = traits.storage_key_to_lookup_key(@buckets[i].first)
+        key = @buckets_k[i]
+        lookup_key = traits.storage_key_to_lookup_key(key)
         # Private methods cannot be called with an explicit receiver and protected ones can.
-        new_map.set_as_interal(lookup_key, traits, @buckets[i][1], @buckets[i].first)
+        new_map.set_as_interal(lookup_key, traits, @buckets_v[i], key)
       end
-      @buckets = new_map.buckets
+
+      @buckets_k = new_map.buckets_k
+      @buckets_v = new_map.buckets_v
       @present = new_map.present
       @deleted = new_map.deleted
     end

data/lib/hashtable/sparse_bit_array.rb

@@ -30,11 +30,18 @@ module HashTable
       @bits[index]
     end
 
+    def ==(other)
+      return false unless index == other.index
+
+      (0...BITWORDS_PER_ELEMENT).each do |i|
+        return false unless @bits[i] == other.bits[i]
+      end || true
+    end
+
     def empty?
       (0...BITWORDS_PER_ELEMENT).each do |i|
         return false unless @bits[i].zero?
-      end
-      true
+      end || true
     end
 
     def set(index)
@@ -48,9 +55,8 @@ module HashTable
     def test_and_set?(index)
       unless test(index)
         set(Idx)
-        return true
-      end
-      false
+        true
+      end || false
     end
 
     def reset(index)
@@ -64,8 +70,13 @@ module HashTable
     # v = (v * 0x0101010101010101) & UINT_64_MAX
     # v >>= 56
     def count
-      (0...BITWORDS_PER_ELEMENT).inject(0) do |nums, i|
-        v = @bits[i].digits(2).count(1)
+      @bits.inject(0) do |nums, b|
+        v = b
+        v -= ((v >> 1) & 0x5555555555555555)
+        v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333)
+        v = (v + (v >> 4) & 0x0F0F0F0F0F0F0F0F)
+        v = (v * 0x0101010101010101) & UINT_64_MAX
+        v >>= 56
         nums + v
       end
     end
@@ -74,11 +85,12 @@ module HashTable
     def first
       (0...BITWORDS_PER_ELEMENT).each do |i|
         v = @bits[i]
-        next if v.zero?
-
-        count = v.digits(2).index(1)
-        return i * BITWORD_SIZE + count
+        unless v.zero?
+          count = v.digits(2).index(1)
+          return i * BITWORD_SIZE + count
+        end
       end
+      raise ArgumentError, 'Illegal empty element'
     end
 
     # @return [Integer] the index of the last set bit
@@ -86,11 +98,12 @@ module HashTable
       (0...BITWORDS_PER_ELEMENT).each do |i|
         index = BITWORDS_PER_ELEMENT - i - 1
         v = @bits[index]
-        next unless v != 0
-
-        count = BIT_WORD - v.bit_length
-        return index * BITWORD_SIZE + BITWORD_SIZE - count - 1
+        unless v.zero?
+          count = BIT_WORD - v.bit_length
+          return index * BITWORD_SIZE + BITWORD_SIZE - count - 1
+        end
       end
+      raise ArgumentError, 'Illegal empty element'
     end
 
     # @return [Integer] the index of the next set bit starting from the "index" bit.
@@ -153,6 +166,10 @@ module HashTable
         bits >>= 1
       end
     end
+
+    protected
+
+    attr_reader :bits
   end
 
   # SparseBitArray is an implementation of a bitmap that is sparse by only storing the elements that have non-zero bits set.
@@ -163,6 +180,7 @@ module HashTable
     # @return [Integer] Pointer to our current Element.
     # This has no visible effect on the external state of a SparseBitArray
     # It's just used to improve performance in the common case of testing/modifying bits with similar indices.
+    # attr_reader :current_index
     attr_reader :current_index
 
     def initialize
@@ -177,8 +195,7 @@ module HashTable
 
       e_index = index / ELEMENT_SIZE
       element_i = lower_bound(e_index)
-      last = elements.length
-      return false if element_i == last || elements[element_i].index != e_index
+      return false if element_i == elements.length || elements[element_i].index != e_index
 
       elements[element_i].test?(index % ELEMENT_SIZE)
     end
@@ -205,13 +222,14 @@ module HashTable
       e_index = index / ELEMENT_SIZE
       element_i = lower_bound(e_index)
       new_e = elements[element_i]
-      unless new_e.nil?
-        element_i += 1 if new_e.index < e_index
-        new_e = nil if new_e.index != e_index
+      eql = new_e.index <=> e_index unless new_e.nil?
+      if eql.nil? || eql != 0
+        element_i += 1 if eql == -1
+        new_e = SparseBitArrayElement.new(e_index)
+        @elements.insert(element_i, new_e)
       end
       @current_index = element_i
-      @elements.insert(@current_index, SparseBitArrayElement.new(e_index)) if new_e.nil?
-      @elements[@current_index].set(index % ELEMENT_SIZE)
+      new_e.set(index % ELEMENT_SIZE)
     end
 
     # @return [Void] Test, Set a bit in the bitmap
@@ -269,12 +287,14 @@ module HashTable
       @current_index -= 1 if @current_index == elements.length
       element_i = @current_index
       element = @elements[element_i]
-      return element_i if element.index == index
 
-      @current_index = if element.index > index
+      @current_index = case element.index <=> index
+                       when 0
+                         element_i
+                       when 1
                          @elements[0..element_i].rindex { |e| e.index <= index } || 0
-                       else
-                         @elements[element_i..].select { |e| e.index < index }.length + element_i
+                       when -1
+                         @elements[element_i..].count { |e| e.index < index } + element_i
                        end
     end
   end

data/lib/hashtable/traits.rb

@@ -1,84 +1,65 @@
-# frozen_string_literal: true
+# frozen_string_literal: false
 
 # module HashTable
 module HashTable
-  class Traits
-    def hash_lookup_key(key)
-      key
-    end
-
-    def lookup_key_to_storage_key(key)
-      key
-    end
-
-    def storage_key_to_lookup_key(key)
-      key
-    end
+  # IdentityHashTraits
+  class IdentityHashTraits
+    define_method(:hash_lookup_key) { |key| key }
+    define_method(:lookup_key_to_storage_key) { |key| key }
+    define_method(:storage_key_to_lookup_key) { |key| key }
+    define_method(:lookup_key_to_storage_value) { |_key, value| value }
   end
 
-  class StringTraits
-    attr_reader :string_table, :string_index
+  # StringIdentityHashTraits
+  class StringIdentityHashTraits < IdentityHashTraits
+    attr_reader :string_table, :buckets
 
-    def initialize
+    def initialize(&block)
+      super
       @string_table = "\0"
-      @string_index = 1
+      @buckets = {}
+      @indexs = {}
     end
 
     def hash_lookup_key(key)
-      result = 0
-      key.each_byte { |byte| result += byte * 13 }
-      result
+      key.downcase.bytes.inject(:+) * 13
     end
 
     def lookup_key_to_storage_key(key)
-      @string_table += "#{key}\0"
-      old_si = @string_index
-      @string_index += key.length + 1
+      return @buckets[key] unless @buckets[key].nil?
+
+      old_si = @string_table.length
+      @buckets[key] = old_si
+      @string_table << "#{key}\0".b
+      @indexs[old_si] = key
       old_si
     end
 
     def storage_key_to_lookup_key(offset)
-      @string_table[offset..][/[^\0]+/]
-    end
-  end
-
-  class StringTraits2
-    attr_reader :string_table, :buckets, :hash_h
+      return @indexs[offset] unless @indexs[offset].nil?
 
-    def initialize
-      @string_table = "\0"
-      @string_index = 1
-      @buckets = {}
-      @hash_h = {}
+      key = @string_table[offset..][/[^\0]+/]
+      @indexs[offset] = key
+      key
     end
+  end
 
-    def hash_lookup_key(key)
-      return @hash_h[key] unless @hash_h[key].nil?
+  # StringHashTraits
+  class StringHashTraits < StringIdentityHashTraits
+    attr_reader :string_table, :buckets
 
-      result = 0
-      key.each_byte { |byte| result += byte * 13 }
-      @hash_h[key] = result
-      result
+    def initialize(&block)
+      super
+      @block = block
     end
 
-    def lookup_key_to_storage_key(key)
-      return @buckets[key] unless @buckets[key].nil?
+    def lookup_key_to_storage_value(key, values)
+      return if values.nil? || values.empty?
 
-      @string_table += "#{key}\0"
-      old_si = @string_index
-      @string_index += key.length + 1
-      @buckets[key] = old_si
-      old_si
-    end
+      bs = values.map { |v| lookup_key_to_storage_key(v) }.unshift(key)
+      return bs if @block.nil?
 
-    def lookup_key_and_value(key, value)
-      value.inject([@buckets[key]]) do |sum, v|
-        sum << lookup_key_to_storage_key(v)
-      end
-    end
-
-    def storage_key_to_lookup_key(offset)
-      @string_table[offset..][/[^\0]+/]
+      @block.call(bs)
     end
   end
 end

data/lib/hashtable/version.rb

@@ -1,3 +1,3 @@
 module Hashtable
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/hashtable.rb

@@ -1,6 +1,6 @@
 module HashTable
   require_relative 'hashtable/version'
   require_relative 'hashtable/sparse_bit_array'
-  require_relative 'hashtable/hash_table'
   require_relative 'hashtable/traits'
-end
+  autoload :HashTable, 'hashtable/hash_table'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashtable
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Cat1237
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-19 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler