tree_map 1.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cc2155ac2712f6af691fb6a799cbf4a245eb149bb6933d06b922782bd0978078
+  data.tar.gz: ce6d0d0cf6080b53244c4c9355f0f9d882151c71e09216b19607df9eba437ca7
+SHA512:
+  metadata.gz: 781ce8371a4fddc23e53adf01ed5f035bae9705bfd1350b5270b28b9a74a27f61e8df8ba6478c7dc7a6207161e6953858765ae4cbedd88461b080572e5233a3c
+  data.tar.gz: 23d35b716b558ec8eca3810dfe6d15f905ed396ba23f2ae76072610f02b5f01a532471dfc21d5021e6f8371c718a55df3bb8a57621210c271961d7ab72f20f7f

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+tree_map-*.gem

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.3
+before_install: gem install bundler -v 2.0.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at tianlu1677@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in tree_map.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    tree_map (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.15.0)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  tree_map!
+
+BUNDLED WITH
+   2.0.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 tianl677
+
+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,66 @@
+# tree_map
+
+
+This is an AVL tree based implementation of Java's java.util.TreeMap structure.
+
+It implements Java's java.util.NavigableMap interface.
+
+learn a lot from [treemap](https://github.com/davidkellis/treemap/)
+
+### References:
+- Reference java implementation: https://android.googlesource.com/platform/libcore.git/+/android-6.0.1_r32/luni/src/main/java/java/util/TreeMap.java
+
+
+### Install
+```
+gem install tree_map
+```
+
+
+### Usage
+In IRB (some lines elided):
+```
+irb(main):001:0> require 'treemap'
+=> true
+irb(main):002:0> m = TreeMap.new; nil
+=> nil
+irb(main):003:0> m.put(1, "foo")
+=> nil
+irb(main):004:0> m.put(100, "baz")
+=> nil
+irb(main):005:0> m.put(10, "bar")
+=> nil
+irb(main):006:0> m.each {|k, v| puts "#{k} -> #{v}" }
+1 -> foo
+10 -> bar
+100 -> baz
+=> nil
+irb(main):007:0> m.to_a
+=> [[1, "foo"], [10, "bar"], [100, "baz"]]
+irb(main):008:0> m.keys
+=> #<Set: {1, 10, 100}>
+irb(main):009:0> m.values
+=> ["foo", "bar", "baz"]
+irb(main):010:0> m.first_key
+=> 1
+irb(main):011:0> m.last_key
+=> 100
+irb(main):012:0> m.lower_key(10)
+=> 1
+irb(main):013:0> m.floor_key(10)
+=> 10
+irb(main):014:0> m.ceiling_key(10)
+=> 10
+irb(main):015:0> m.higher_key(10)
+=> 100
+```
+
+
+### Run Tests:
+```
+rake
+```
+OR
+```
+rake test
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tree_map"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/tree_map/bounded_map.rb

@@ -0,0 +1,380 @@
+class TreeMap
+  module Bound
+    INCLUSIVE = 1
+    EXCLUSIVE = 2
+    NO_BOUND = 3
+  end
+
+  # A map with optional limits on its range.
+  # This is intended to be used only by the TreeMap class.
+  class BoundedMap
+    include Enumerable
+
+    attr_accessor :treemap, :ascending, :from, :from_bound, :to, :to_bound
+
+    def initialize(treemap, ascending, from, from_bound, to, to_bound)
+      @treemap = treemap
+      @ascending = ascending
+      @from = from
+      @from_bound = from_bound
+      @to = to
+      @to_bound = to_bound
+
+      # Validate the bounds. In addition to checking that from <= to, we verify that the comparator supports our bound objects.
+      if from_bound != Bound::NO_BOUND && to_bound != Bound::NO_BOUND
+        raise "Invalid from and to arguments: #{from} (from) > #{to} (to)" if comparator.call(from, to) > 0
+      elsif from_bound != Bound::NO_BOUND
+        comparator.call(from, from)
+      elsif to_bound != Bound::NO_BOUND
+        comparator.call(to, to)
+      end
+    end
+
+    def empty?
+      endpoint(true).nil?
+    end
+
+    def get(key)
+      @treemap.get(key) if in_bounds?(key)
+    end
+
+    def contains_key?(key)
+      in_bounds?(key) && @treemap.contains_key?(key)
+    end
+
+    def put(key, value)
+      raise "Key out of bounds." unless in_bounds?(key)
+      put_internal(key, value)
+    end
+
+    def remove(key)
+      @treemap.remove(key) if in_bounds?(key)
+    end
+
+    # Returns true if the key is in bounds.
+    # Note: The reference implementation calls this function isInBounds
+    def in_bounds?(key)
+      in_closed_bounds?(key, @from_bound, @to_bound)
+    end
+
+    # Returns true if the key is in bounds. Use this overload with
+    # NO_BOUND to skip bounds checking on either end.
+    # Note: The reference implementation calls this function isInBounds
+    def in_closed_bounds?(key, from_bound, to_bound)
+      if from_bound == Bound::INCLUSIVE
+        return false if comparator.call(key, from) < 0      # less than from
+      elsif from_bound == Bound::EXCLUSIVE
+        return false if comparator.call(key, from) <= 0     # less than or equal to from
+      end
+      if to_bound == Bound::INCLUSIVE
+        return false if comparator.call(key, to) > 0        # greater than 'to'
+      elsif to_bound == Bound::EXCLUSIVE
+        return false if comparator.call(key, to) >= 0       # greater than or equal to 'to'
+      end
+      true
+    end
+
+    # Returns the entry if it is in bounds, or null if it is out of bounds.
+    def bound(node, from_bound, to_bound)
+      node if node && in_closed_bounds?(node.key, from_bound, to_bound)
+    end
+
+    # Navigable methods
+
+    def first_entry
+      endpoint(true)
+    end
+
+    def poll_first_entry
+      result = endpoint(true)
+      @treemap.remove_internal(result) if result
+      result
+    end
+
+    def first_key
+      entry = endpoint(true)
+      raise "No such element" unless entry
+      entry.key
+    end
+
+    def last_entry
+      endpoint(false)
+    end
+
+    def poll_last_entry
+      result = endpoint(false)
+      @treemap.remove_internal(result) if result
+      result
+    end
+
+    def last_key
+      entry = endpoint(false)
+      raise "No such element" unless entry
+      entry.key
+    end
+
+    # <first> - true for the first element, false for the last
+    def endpoint(first)
+      node, from, to = if @ascending == first
+        node = case @from_bound
+        when Bound::NO_BOUND
+          @treemap.root.first if @treemap.root
+        when Bound::INCLUSIVE
+          @treemap.find(@from, Relation::CEILING)
+        when Bound::EXCLUSIVE
+          @treemap.find(@from, Relation::HIGHER)
+        else
+          raise "Undefined bound."
+        end
+        [node, Bound::NO_BOUND, @to_bound]
+      else
+        node = case @to_bound
+        when Bound::NO_BOUND
+          @treemap.root.last if @treemap.root
+        when Bound::INCLUSIVE
+          @treemap.find(@to, Relation::FLOOR)
+        when Bound::EXCLUSIVE
+          @treemap.find(@to, Relation::LOWER)
+        else
+          raise "Undefined bound."
+        end
+        [node, @from_bound, Bound::NO_BOUND]
+      end
+      bound(node, from, to)
+    end
+
+    # Performs a find on the underlying tree after constraining it to the
+    # bounds of this view. Examples:
+    #
+    #   bound is (A..C)
+    #   find_bounded(B, FLOOR) stays source.find(B, FLOOR)
+    #
+    #   bound is (A..C)
+    #   find_bounded(C, FLOOR) becomes source.find(C, LOWER)
+    #
+    #   bound is (A..C)
+    #   find_bounded(D, LOWER) becomes source.find(C, LOWER)
+    #
+    #   bound is (A..C]
+    #   find_bounded(D, FLOOR) becomes source.find(C, FLOOR)
+    #
+    #   bound is (A..C]
+    #   find_bounded(D, LOWER) becomes source.find(C, FLOOR)
+    def find_bounded(key, relation)
+      relation = Relation.for_order(relation, @ascending)
+      from_bound_for_check = @from_bound
+      to_bound_for_check = @to_bound
+      if @to_bound != Bound::NO_BOUND && (relation == Relation::LOWER || relation == Relation::FLOOR)
+        comparison = comparator.call(@to, key)
+        if comparison <= 0
+          key = @to
+          if @to_bound == Bound::EXCLUSIVE
+            relation = Relation::LOWER # 'to' is too high
+          elsif comparison < 0
+            relation = Relation::FLOOR # we already went lower
+          end
+        end
+        to_bound_for_check = Bound::NO_BOUND # we've already checked the upper bound
+      end
+      if @from_bound != Bound::NO_BOUND && (relation == Relation::CEILING || relation == Relation::HIGHER)
+        comparison = comparator.call(@from, key)
+        if comparison >= 0
+          key = @from
+          if @from_bound == Bound::EXCLUSIVE
+            relation = Relation::HIGHER # 'from' is too low
+          elsif comparison > 0
+            relation = Relation::CEILING # we already went higher
+          end
+        end
+        from_bound_for_check = Bound::NO_BOUND # we've already checked the lower bound
+      end
+      bound(@treemap.find(key, relation), from_bound_for_check, to_bound_for_check)
+    end
+
+    def lower_entry(key)
+      find_bounded(key, Relation::LOWER)
+    end
+
+    def lower_key(key)
+      entry = find_bounded(key, Relation::LOWER)
+      entry.key if entry
+    end
+
+    def floor_entry(key)
+      find_bounded(key, Relation::FLOOR)
+    end
+
+    def floor_key(key)
+      entry = find_bounded(key, Relation::FLOOR)
+      entry.key if entry
+    end
+
+    def ceiling_entry(key)
+      find_bounded(key, Relation::CEILING)
+    end
+
+    def ceiling_key(key)
+      entry = find_bounded(key, Relation::CEILING)
+      entry.key if entry
+    end
+
+    def higher_entry(key)
+      find_bounded(key, Relation::HIGHER)
+    end
+
+    def higher_key(key)
+      entry = find_bounded(key, Relation::HIGHER)
+      entry.key if entry
+    end
+
+    def comparator
+      if @ascending
+        @treemap.comparator
+      else
+        ->(this, that) { -@treemap.comparator.call(this, that) }
+      end
+    end
+
+    # View factory methods
+
+    def entry_set
+      Set.new(each_node.to_a)
+    end
+
+    def key_set
+      Set.new(each_node.map(&:key))
+    end
+
+    alias keys key_set
+
+    def values
+      each_node.map(&:value)
+    end
+
+    def descending_map
+      BoundedMap.new(@treemap, !@ascending, @from, @from_bound, @to, @to_bound)
+    end
+
+    # This can be called in 1 of 2 ways:
+    # sub_map(from_inclusive, to_exclusive)
+    # OR
+    # sub_map(from, from_inclusive, to, to_inclusive)
+    def sub_map(*args)
+      case args.count
+      when 2
+        from_inclusive, to_exclusive = *args
+        bounded_sub_map(from_inclusive, Bound::INCLUSIVE, to_exclusive, Bound::EXCLUSIVE)
+      when 4
+        from, from_inclusive, to, to_inclusive = *args
+        from_bound = from_inclusive ? Bound::INCLUSIVE : Bound::EXCLUSIVE
+        to_bound = to_inclusive ? Bound::INCLUSIVE : Bound::EXCLUSIVE
+        bounded_sub_map(from, from_bound, to, to_bound)
+      end
+    end
+
+    def bounded_sub_map(from, from_bound, to, to_bound)
+      if !@ascending
+        from, to = to, from
+        from_bound, to_bound = to_bound, from_bound
+      end
+
+      # If both the current and requested bounds are exclusive, the isInBounds check must be
+      # inclusive. For example, to create (C..F) from (A..F), the bound 'F' is in bounds.
+      if from_bound == Bound::NO_BOUND
+        from = @from
+        from_bound = @from_bound
+      else
+        from_bound_to_check = from_bound == @from_bound ? Bound::INCLUSIVE : @from_bound
+        raise out_of_bounds(to, from_bound_to_check, @to_bound) if !in_closed_bounds?(from, from_bound_to_check, @to_bound)
+      end
+      if to_bound == Bound::NO_BOUND
+        to = @to
+        to_bound = @to_bound
+      else
+        to_bound_to_check = to_bound == @to_bound ? Bound::INCLUSIVE : @to_bound
+        raise out_of_bounds(to, @from_bound, to_bound_to_check) if !in_closed_bounds?(to, @from_bound, to_bound_to_check)
+      end
+      BoundedMap.new(@treemap, ascending, from, from_bound, to, to_bound)
+    end
+
+    # This can be called in 1 of 2 ways:
+    # head_map(to_exclusive)
+    # OR
+    # head_map(to, inclusive)
+    def head_map(*args)
+      case args.count
+      when 1
+        to_exclusive = args.first
+        bounded_sub_map(nil, Bound::NO_BOUND, to_exclusive, Bound::EXCLUSIVE)
+      when 2
+        to, inclusive = *args
+        to_bound = inclusive ? Bound::INCLUSIVE : Bound::EXCLUSIVE
+        bounded_sub_map(nil, Bound::NO_BOUND, to, to_bound)
+      end
+    end
+
+    # This can be called in 1 of 2 ways:
+    # tail_map(from_inclusive)
+    # OR
+    # tail_map(from, inclusive)
+    def tail_map(*args)
+      case args.count
+      when 1
+        from_inclusive = args.first
+        bounded_sub_map(from_inclusive, Bound::INCLUSIVE, nil, Bound::NO_BOUND)
+      when 2
+        from, inclusive = *args
+        from_bound = inclusive ? Bound::INCLUSIVE : Bound::EXCLUSIVE
+        bounded_sub_map(from, from_bound, nil, Bound::NO_BOUND)
+      end
+    end
+
+    def out_of_bounds(value, from_bound, to_bound)
+      Exception.new("#{value} not in range #{from_bound.left_cap(@from)}..#{to_bound.right_cap(@to)}")
+    end
+
+    # Bounded view implementations
+
+    # in-order traversal of nodes in tree
+    class BoundedNodeIterator < ::TreeMap::NodeIterator
+      def initialize(bounded_map, next_node)
+        super(next_node)
+        @bounded_map = bounded_map
+      end
+
+      def step_forward
+        result = super
+        @next_node = nil if @next_node && !@bounded_map.in_closed_bounds?(@next_node.key, Bound::NO_BOUND, @bounded_map.to_bound)
+        result
+      end
+
+      def step_backward
+        result = super
+        @next_node = nil if @next_node && !@bounded_map.in_closed_bounds?(@next_node.key, @bounded_map.from_bound, Bound::NO_BOUND)
+        result
+      end
+    end
+
+    # each {|k,v| puts "#{k}->#{v}"}
+    def each(&blk)
+      if block_given?
+        each_node {|node| blk.call(node.key, node.value) }
+      else
+        enum_for(:each)
+      end
+    end
+
+    # each_node {|node| puts "#{node.key}->#{node.value}"}
+    def each_node
+      if block_given?
+        iter = BoundedNodeIterator.new(self, endpoint(true))
+        while iter.has_next?
+          yield iter.step_forward()
+        end
+      else
+        enum_for(:each_node)
+      end
+    end
+
+  end
+end