hashtable 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 84378d52b624dfc1274b36c694b9651af59bbd941ee2cfae71592c48b69b82d8
+  data.tar.gz: cf4de36cd314ecc33538e14db09e768fecbcb54eb53546e545cbd40e96e7c8c3
+SHA512:
+  metadata.gz: 85562898eb56576dd0f846eea330b66e561acee762071bf08a60ab4e0f683f510b8744b86c40cb61c6401c357fbef9f096e015f1f6aa8143bf040adc24a77dfa
+  data.tar.gz: c58e25d6e72d7b5c46de97db5be5d4592bdd50b2a0ac54e921dc79a20e5d0fd156cf46df6e0c68ae4f73a1451feb85e1ab15ff30686adc390a0d7585c8da67e6

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Cat1237
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,225 @@
+# Hashtable
+[![License MIT](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://raw.githubusercontent.com/Cat1237/hashtable/main/LICENSE) 
+
+`HashTable` - This provides a hash table data structure that is specialized for handling key/value pairs. This does some funky memory allocation and hashing things to make it extremely efficient, storing the key/value with `SparseBitArray`.
+
+`SparseBitArray` - is an implementation of a bitmap that is sparse by only storing the elements that have non-zero bits set.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hashtable'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install hashtable
+
+## Usage
+
+### `SparseBitArray`
+
+```ruby
+e = HashTable::SparseBitArrayElement.new
+# Set, Test and Reset a bit in the bitmap
+e.set(23)
+e.test?(17)
+e.reset(4000)
+
+# The index of the first set bit
+e.first
+# The index of the last set bit
+e.last
+
+
+(0..128).to_a.each_index do |i|
+    e.set(i)
+end
+# Enumerator
+e.each do |index|
+  p "#{index}----"
+end
+```
+
+### HashTable
+
+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)
+```
+
+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
+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
+```
+
+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
+
+(0..31).each do |i|
+   table.add("ViewController#{i}.h", traits)
+end
+# 32
+p table.size
+# 64
+p table.capacity
+# 32
+p table.num_entries
+```
+
+Store strings and expand capacity:
+
+- num_entries = capacity + 1
+- capacity = capacity * 2
+- 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
+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)
+end
+# 2728
+p table.size
+# 8192
+p table.capacity
+# 5461
+p table.num_entries
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Cat1237/hashtable. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[Cat1237]/hashtable/blob/master/CODE_OF_CONDUCT.md).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Hashtable project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Cat1237/hashtable/blob/master/CODE_OF_CONDUCT.md).

data/lib/hashtable/hash_table.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+# module HashTable
+module HashTable
+  # HashTable
+  # @abstract
+  class HashTable
+    # @return [Integer] nums of HashTable entries
+    attr_reader :num_entries
+
+    def initialize(capacity = 8, expand: false)
+      capacity = capacity < 8 ? 8 : 2**(capacity - 1).bit_length
+      @buckets = Array.new(capacity)
+      @present = SparseBitArray.new
+      @deleted = SparseBitArray.new
+      @expand = expand
+      @num_entries = 0
+    end
+
+    def size
+      @present.count
+    end
+
+    def empty?
+      size.zero?
+    end
+
+    def capacity
+      @buckets.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
+      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
+        break if i == h
+      end
+      raise ArgumentError if fisrt_unsed.nil?
+
+      fisrt_unsed
+    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] value
+    # @param  [object] traits
+    def set(key, value, traits)
+      set_as_interal(key, traits, value)
+    end
+
+    def get(key, traits)
+      i = find(key, traits)
+      bucket = @buckets[i]
+      raise ArgumentError if bucket.nil? || bucket.empty?
+
+      bucket.last
+    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)
+      set_as_interal(key, traits)
+    end
+
+    # @return [Array<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 adds(keys, traits)
+      (keys || []).map { |key| set_as_interal(key, traits) }
+    end
+
+    protected
+
+    attr_reader :present, :deleted, :buckets
+
+    def present?(key)
+      @present.test?(key)
+    end
+
+    def deleted?(key)
+      @present.test?(key)
+    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
+    # @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
+
+      index = find(key, traits)
+      bucket = @buckets[index] ||= []
+      if bucket.empty?
+        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?
+        @present.set(index)
+        @deleted.reset(index)
+        grow(traits)
+      else
+        raise ArgumentError unless present?(index)
+        raise ArgumentError unless traits.storage_key_to_lookup_key(@buckets[index].first) == key
+
+        bucket[1] = value unless value.nil?
+      end
+      bucket[0]
+    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'
+      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)
+      @present.each do |i|
+        lookup_key = traits.storage_key_to_lookup_key(@buckets[i].first)
+        # 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)
+      end
+      @buckets = new_map.buckets
+      @present = new_map.present
+      @deleted = new_map.deleted
+    end
+  end
+end

data/lib/hashtable/sparse_bit_array.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+# module HashTable
+module HashTable
+  BIT_WORD = 64
+  ELEMENT_SIZE = BIT_WORD * 2
+  UINT_64_MAX = 2**BIT_WORD - 1
+  BITWORD_SIZE = BIT_WORD
+  BITWORDS_PER_ELEMENT = (ELEMENT_SIZE + BITWORD_SIZE - 1) / BITWORD_SIZE
+  BITS_PER_ELEMENT = ELEMENT_SIZE
+  private_constant :BIT_WORD, :ELEMENT_SIZE, :UINT_64_MAX, :BITWORD_SIZE
+  private_constant :BITWORDS_PER_ELEMENT, :BITS_PER_ELEMENT, :BITS_PER_ELEMENT
+  # SparseBitArrayElement
+  # @abstract
+  class SparseBitArrayElement
+    # @return [Integer] Index of Element in terms of where first bit starts.
+    attr_reader :index
+
+    def initialize(index = 0)
+      @index = index
+      # Index of Element in terms of where first bit starts.
+      @bits = Array.new(BITWORDS_PER_ELEMENT, 0)
+    end
+
+    # @return [Integer] the bits that make up word index in our element
+    # @param  [Integer] index
+    def word(index)
+      raise ArgumentError, 'index error' unless index < BITWORDS_PER_ELEMENT
+
+      @bits[index]
+    end
+
+    def empty?
+      (0...BITWORDS_PER_ELEMENT).each do |i|
+        return false unless @bits[i].zero?
+      end
+      true
+    end
+
+    def set(index)
+      @bits[index / BITWORD_SIZE] |= 1 << (index % BITWORD_SIZE)
+    end
+
+    def test?(index)
+      @bits[index / BITWORD_SIZE] & (1 << (index % BITWORD_SIZE)) != 0
+    end
+
+    def test_and_set?(index)
+      unless test(index)
+        set(Idx)
+        return true
+      end
+      false
+    end
+
+    def reset(index)
+      bits[index / BITWORD_SIZE] &= ~(1 << (index % BITWORD_SIZE))
+    end
+
+    # v = @bits[i]
+    # v -= ((v >> 1) & 0x5555555555555555)
+    # v = (v & 0x3333333333333333) + ((v >> 2) & 0x3333333333333333)
+    # v = (v + (v >> 4) & 0x0F0F0F0F0F0F0F0F)
+    # 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)
+        nums + v
+      end
+    end
+
+    # @return [Integer] the index of the first set bit
+    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
+      end
+    end
+
+    # @return [Integer] the index of the last set bit
+    def last
+      (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
+      end
+    end
+
+    # @return [Integer] the index of the next set bit starting from the "index" bit.
+    # Returns -1 if the next set bit is not found.
+    def next(index)
+      return -1 if index >= BITS_PER_ELEMENT
+
+      word_pos = index / BITWORD_SIZE
+      bit_pos = index % BITWORD_SIZE
+      copy = @bits[word_pos]
+      raise ArgumentError, 'Word Position outside of element' unless word_pos <= BITS_PER_ELEMENT
+
+      copy &= ~0 << bit_pos
+      return word_pos * BITWORD_SIZE + copy.digits(2).index(1) unless copy.zero?
+
+      word_pos += 1
+      (word_pos...BITWORDS_PER_ELEMENT).each do |i|
+        return i * BITWORD_SIZE + @bits[i].digits(2).index(1) unless @bits[i].zero?
+      end
+      -1
+    end
+
+    include Enumerable
+
+    def each
+      return if empty?
+
+      last_i = last
+      first_i = first
+      bits = 0
+      bit_number = 0
+      loop do
+        while bits.nonzero? && (bits & 1).zero?
+          bits >>= 1
+          bit_number += 1
+        end
+        # See if we ran out of Bits in this word.
+        if bits.zero?
+          next_set_bit_number = self.next(bit_number % ELEMENT_SIZE)
+          if next_set_bit_number == -1 || (bit_number % ELEMENT_SIZE).zero?
+            next_set_bit_number = first_i
+            bit_number = index * ELEMENT_SIZE
+            bit_number += next_set_bit_number
+            word_number = bit_number % ELEMENT_SIZE / BITWORD_SIZE
+            bits = word(word_number)
+            bits >>= next_set_bit_number % BITWORD_SIZE
+          else
+            # Set up for next non-zero word in bitmap
+            word_number = next_set_bit_number % ELEMENT_SIZE / BITWORD_SIZE
+            bits = word(word_number)
+            bits >>= next_set_bit_number % BITWORD_SIZE
+            bit_number = index * ELEMENT_SIZE
+            bit_number += next_set_bit_number
+          end
+        end
+        yield bit_number
+        break if bit_number % ELEMENT_SIZE == last_i
+
+        bit_number += 1
+        bits >>= 1
+      end
+    end
+  end
+
+  # SparseBitArray is an implementation of a bitmap that is sparse by only storing the elements that have non-zero bits set.
+  # @abstract
+  class SparseBitArray
+    # @return [Array<SparseBitArrayElement>] The list of Elements
+    attr_reader :elements
+    # @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
+
+    def initialize
+      @elements = []
+      @current_index = -1
+    end
+
+    # @return [Boolean] Test a bit in the bitmap
+    # @param [Integer] bit
+    def test?(index)
+      return false if elements.empty?
+
+      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
+
+      elements[element_i].test?(index % ELEMENT_SIZE)
+    end
+
+    # @return [Void] Reset a bit in the bitmap
+    # @param [Integer] bit
+    def reset(index)
+      return if @elements.empty?
+
+      e_index = index / ELEMENT_SIZE
+      element_i = lower_bound(e_index)
+      element = elements[element_i]
+      return if element_i == elements.length || element.index != e_index
+
+      element.reset(index % ELEMENT_SIZE)
+      return unless element.empty?
+
+      @elements.delete_at(element_i)
+    end
+
+    # @return [Void] Set a bit in the bitmap
+    # @param [Integer] bit
+    def set(index)
+      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
+      end
+      @current_index = element_i
+      @elements.insert(@current_index, SparseBitArrayElement.new(e_index)) if new_e.nil?
+      @elements[@current_index].set(index % ELEMENT_SIZE)
+    end
+
+    # @return [Void] Test, Set a bit in the bitmap
+    # @param [Integer] bit
+    def test_and_set?(index)
+      unless test?(index)
+        set(Idx)
+        return true
+      end
+      false
+    end
+
+    def count
+      @elements.inject(0) { |c, e| c + e.count }
+    end
+
+    def clear
+      @elements.clear
+    end
+
+    # @return [Integer] the first set bit in the bitmap.
+    # Return -1 if no bits are set.
+    def first
+      return -1 if elements.empty?
+
+      first = elements.first
+      first.index * ELEMENT_SIZE + first.first
+    end
+
+    # @return [Integer] the last set bit in the bitmap.
+    # Return -1 if no bits are set.
+    def last
+      return -1 if elements.empty?
+
+      last = elements.last
+      last.index * ELEMENT_SIZE + last.last
+    end
+
+    def empty?
+      elements.empty?
+    end
+
+    include Enumerable
+
+    def each(&block)
+      @elements.each { |element| element.each(&block) }
+    end
+
+    private
+
+    # @return [Integer] do linear searching from the current position.
+    def lower_bound(index)
+      return 0 if elements.empty?
+
+      @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
+                         @elements[0..element_i].rindex { |e| e.index <= index } || 0
+                       else
+                         @elements[element_i..-1].select { |e| e.index < index }.length + element_i
+                       end
+    end
+  end
+end

data/lib/hashtable/version.rb

@@ -0,0 +1,3 @@
+module Hashtable
+  VERSION = '0.1.1'
+end

data/lib/hashtable.rb

@@ -0,0 +1,5 @@
+module HashTable
+  require_relative 'hashtable/version'
+  require_relative 'hashtable/sparse_bit_array'
+  require_relative 'hashtable/hash_table'
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: hashtable
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Cat1237
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-05-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: This does some funky memory allocation and hashing things to make it
+  extremely efficient, storing the key/value with `SparseBitArray`
+email:
+- wangson1237@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/hashtable.rb
+- lib/hashtable/hash_table.rb
+- lib/hashtable/sparse_bit_array.rb
+- lib/hashtable/version.rb
+homepage: https://github.com/Cat1237/hashtable.git
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: This provides a hash table data structure that is specialized for handling
+  key/value pairs.
+test_files: []