min_max 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aef5e878c1412daa7a16bf7aad72afff1bdcc4cfa37709e6a88601d6ef2f1a93
-  data.tar.gz: 74f22abb3ad7a47e654cf6033d0512e00344a373e21aa18e46f86a9d38e6dc17
+  metadata.gz: 5b1020f3ac8e632e3b2b4d99318a78edf48a06d3099e5812637d8dfd5fdf1623
+  data.tar.gz: b774055ca657edf4a01712a71020cbb55df034e38f3db676b0c85484ae1f155e
 SHA512:
-  metadata.gz: 0b992bc50cd6e4920503b8a9257916dc3cb83326126c9e56c38fb693bbf513335573f8c7730386109044de48f58dd6e8a9c1da7f4a6e91e9f28e2aeb981cd23c
-  data.tar.gz: e5f84db084190697f2d8ab7738b70fc82ae2b4a23466936d47e74aef27e46dd39f1f2e5885b1a7d3f876f28aadc0dfc747dabffe36c05eaa3f4661f7424091bf
+  metadata.gz: 2c7a1e0c3893382526f5c94c488618a3d01b7e19aa3a6d1b3cfc0aa012ede494bfb033c1b9544224bcfa3f9147d3d96779d11c83f2723a384c36109c5f837dba
+  data.tar.gz: 4c60344475780f72a7369cac4fc0a22e156750fee690b326a2cbc9b6d1c492446f05dbdda5e39910e9f9549b848730ade850fda8e282d418ba1fa0e8e8c19793

data/ext/min_max/src/lib.rs

@@ -1,13 +1,12 @@
-use magnus::block::Proc;
 use magnus::scan_args::scan_args;
-use magnus::value::ReprValue;
+use magnus::value::{BoxValue, ReprValue};
 use magnus::{
     block::{block_given, Yield},
     define_class, function, method,
     prelude::*,
     Error, IntoValue, RArray, Ruby, Value,
 };
-use magnus::{eval, gc, DataTypeFunctions, RHash, RString, TypedData};
+use magnus::{DataTypeFunctions, Integer, TypedData};
 use min_max_heap::MinMaxHeap;
 use std::cell::RefCell;
 use std::collections::HashMap;
@@ -20,7 +19,7 @@ struct PriorityOrderableValue(i64, i64);
 extern crate lazy_static;
 
 struct MEM(
-    RwLock<HashMap<i64, Box<Value>>>,
+    RwLock<HashMap<i64, BoxValue<Value>>>,
     RwLock<HashMap<i64, RefCell<usize>>>,
 );
 
@@ -36,44 +35,6 @@ lazy_static! {
     static ref MEMORY: MEM = MEM::new();
 }
 
-fn get_rb_obj(key: i64) -> Option<Value> {
-    let binding = (*MEMORY).0.read().unwrap();
-    let v = binding.get(&key).unwrap();
-    Some(**v)
-}
-
-fn pop_rb_obj(key: i64) -> Option<Value> {
-    let binding = (*MEMORY).1.read().unwrap();
-    let mut count = binding.get(&key).unwrap().borrow_mut();
-    if *count == 0 {
-        return None;
-    }
-    *count -= 1;
-    let res = if *count == 0 {
-        let val = (*MEMORY).0.write().unwrap().remove(&key).unwrap();
-        gc::unregister_address(&*val);
-        Some(*val)
-    } else {
-        let binding = (*MEMORY).0.read().unwrap();
-        let v = binding.get(&key).unwrap();
-        Some(**v)
-    };
-    res
-}
-
-fn push_rb_obj(key: i64, value: Value) -> i64 {
-    let mut binding = (*MEMORY).1.write().unwrap();
-    let mut count = binding.entry(key).or_insert(RefCell::new(0)).borrow_mut();
-
-    *count += 1;
-    if *count == 1 {
-        let boxed = Box::new(value);
-        gc::register_address(&*boxed);
-        (*MEMORY).0.write().unwrap().insert(key, boxed);
-    };
-    return key;
-}
-
 impl PartialOrd for PriorityOrderableValue {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
         Some(self.cmp(other))
@@ -94,9 +55,7 @@ impl PartialEq for PriorityOrderableValue {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (PriorityOrderableValue(p1, v1), PriorityOrderableValue(p2, v2)) => {
-                let v1_obj = get_rb_obj(*v1).unwrap();
-                let v2_obj = get_rb_obj(*v2).unwrap();
-                p1.eq(p2) && (v1_obj).eql(v2_obj).unwrap_or_default()
+                p1.eq(p2) && (v1).eq(v2)
             }
         }
     }
@@ -107,49 +66,36 @@ unsafe impl Send for RubyMinMaxHeap {}
 #[magnus(class = "MinMax", size, free_immediately, mark)]
 struct RubyMinMaxHeap {
     heap: Arc<RefCell<MinMaxHeap<PriorityOrderableValue>>>,
-    priority_proc: Arc<Proc>,
 }
 
 impl RubyMinMaxHeap {
-    fn new(args: &[Value]) -> Result<Self, Error> {
-        let args = scan_args::<(), (), (), (), RHash, Option<Proc>>(args)?;
-        let prc: Option<Proc> = args.block;
-
+    fn new() -> Result<Self, Error> {
         Ok(RubyMinMaxHeap {
             heap: Arc::new(RefCell::new(MinMaxHeap::new())),
-            priority_proc: prc
-                .unwrap_or_else(|| {
-                    let value: Value =
-                        eval("Proc.new {|x| x.respond_to?(:priority) ? x.priority : x.to_i }")
-                            .unwrap();
-                    Proc::from_value(value).unwrap()
-                })
-                .into(),
         })
     }
 
-    fn push(&self, value: &[Value]) -> Result<(), Error> {
+    fn push(&self, values: RArray) -> Result<(), Error> {
         let mut hp = self.heap.borrow_mut();
-        value.iter().for_each(|v| {
-            let priority: i64 = (*self.priority_proc).call([*v]).unwrap_or_default();
-            let key = v.hash().unwrap().to_i64().unwrap();
-            hp.push(PriorityOrderableValue(priority, push_rb_obj(key, *v)));
+        let values_vec = values.to_vec::<(i64, i64)>().unwrap();
+        values_vec.into_iter().for_each(|(priority, key)| {
+            hp.push(PriorityOrderableValue(priority, key));
         });
         Ok(())
     }
 
-    fn peek_max(&self) -> Result<Option<Value>, Error> {
+    fn peek_max(&self) -> Result<Option<i64>, Error> {
         let hp = self.heap.borrow();
         match hp.peek_max() {
-            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            Some(PriorityOrderableValue(_, value)) => Ok(Some(*value)),
             _ => Ok(None),
         }
     }
 
-    fn peek_min(&self) -> Result<Option<Value>, Error> {
+    fn peek_min(&self) -> Result<Option<i64>, Error> {
         let hp = self.heap.borrow();
         match hp.peek_min() {
-            Some(PriorityOrderableValue(_, value)) => Ok(get_rb_obj(*value)),
+            Some(PriorityOrderableValue(_, value)) => Ok(Some(*value)),
             _ => Ok(None),
         }
     }
@@ -162,20 +108,20 @@ impl RubyMinMaxHeap {
             let mut result = vec![];
             for _ in 0..c {
                 match { self.heap.borrow_mut() }.pop_max() {
-                    Some(PriorityOrderableValue(_, value)) => {
-                        result.push(pop_rb_obj(value).unwrap())
-                    }
+                    Some(PriorityOrderableValue(_, value)) => result.push(Integer::from_i64(value)),
                     _ => break,
                 }
             }
             let ary = RArray::new();
             ary.cat(&result)?;
-            Ok(Some(ary.into_value()))
+            Ok(Some(ary.as_value()))
         } else {
             let mut hp = self.heap.borrow_mut();
             let val = hp.pop_max();
             match val {
-                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+                Some(PriorityOrderableValue(_, value)) => {
+                    Ok(Some(Integer::from_i64(value).as_value()))
+                }
                 _ => Ok(None),
             }
         }
@@ -188,19 +134,21 @@ impl RubyMinMaxHeap {
         if let Some(c) = count {
             let mut result = vec![];
             for _ in 0..c {
-                match { self.heap.borrow_mut().pop_min() } {
-                    Some(PriorityOrderableValue(_, value)) => {
-                        result.push(pop_rb_obj(value).unwrap())
-                    }
+                match { self.heap.borrow_mut() }.pop_min() {
+                    Some(PriorityOrderableValue(_, value)) => result.push(Integer::from_i64(value)),
                     _ => break,
                 }
             }
             let ary = RArray::new();
             ary.cat(&result)?;
-            Ok(Some(ary.into_value()))
+            Ok(Some(ary.as_value()))
         } else {
-            match { self.heap.borrow_mut().pop_min() } {
-                Some(PriorityOrderableValue(_, value)) => Ok(pop_rb_obj(value)),
+            let mut hp = self.heap.borrow_mut();
+            let val = hp.pop_min();
+            match val {
+                Some(PriorityOrderableValue(_, value)) => {
+                    Ok(Some(Integer::from_i64(value).as_value()))
+                }
                 _ => Ok(None),
             }
         }
@@ -223,45 +171,14 @@ impl RubyMinMaxHeap {
                 .into_vec()
                 .into_iter()
                 .map(|orderable_value| match orderable_value {
-                    PriorityOrderableValue(_, value) => get_rb_obj(value).unwrap(),
+                    PriorityOrderableValue(_, value) => Integer::from_i64(value).as_value(),
                 });
             Yield::Iter(Box::new(iter))
         } else {
-            Yield::Enumerator(self.clone().into_value().enumeratorize("each", ()))
+            Yield::Enumerator(self.clone().into_value().enumeratorize("_each", ()))
         }
     }
 
-    fn to_a(&self) -> Result<RArray, Error> {
-        let each: Value = self.clone().into_value().funcall("each", ())?;
-        Ok(each.funcall("to_a", ())?)
-    }
-
-    fn inspect(&self) -> Result<RString, Error> {
-        let mut visited = std::collections::HashSet::new();
-        Ok(self.build_inspect(&mut visited)?)
-    }
-
-    fn build_inspect(
-        &self,
-        visited: &mut std::collections::HashSet<*const Self>,
-    ) -> Result<RString, Error> {
-        // Check for circular reference
-        if !visited.insert(self as *const Self) {
-            return Ok(RString::new("[Circular Reference Detected]"));
-        }
-
-        let to_a: Value = self.to_a()?.into_value();
-        let r: String = match to_a.funcall("inspect", ()) {
-            Ok(inspect_value) => inspect_value,
-            Err(_) => return Ok(RString::new("[Error inspecting array]")),
-        };
-
-        // Ensure the current object is removed from the visited set to allow re-visiting in future calls
-        visited.remove(&(self as *const Self));
-
-        Ok(RString::new(&format!("MinMax{}", r)))
-    }
-
     fn to_a_asc(&self) -> Result<RArray, Error> {
         let ary = RArray::new();
 
@@ -272,7 +189,7 @@ impl RubyMinMaxHeap {
             .into_vec_asc()
             .iter()
             .map(|orderable_value| match orderable_value {
-                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+                PriorityOrderableValue(_, value) => Integer::from_i64(*value).as_value(),
             })
             .collect();
         ary.cat(&sorted)?;
@@ -289,7 +206,7 @@ impl RubyMinMaxHeap {
             .into_vec_desc()
             .iter()
             .map(|orderable_value| match orderable_value {
-                PriorityOrderableValue(_, value) => get_rb_obj(*value).unwrap(),
+                PriorityOrderableValue(_, value) => Integer::from_i64(*value).as_value(),
             })
             .collect();
         ary.cat(&sorted)?;
@@ -304,20 +221,18 @@ impl RubyMinMaxHeap {
 #[magnus::init]
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let rb_c_min_max = define_class("MinMax", ruby.class_object())?;
-    rb_c_min_max.define_singleton_method("new", function!(RubyMinMaxHeap::new, -1))?;
-    rb_c_min_max.define_method("_push", method!(RubyMinMaxHeap::push, -1))?;
+    rb_c_min_max.define_singleton_method("_new", function!(RubyMinMaxHeap::new, 0))?;
+    rb_c_min_max.define_method("_push", method!(RubyMinMaxHeap::push, 1))?;
     rb_c_min_max.define_method("_pop_max", method!(RubyMinMaxHeap::pop_max, -1))?;
     rb_c_min_max.define_method("_pop_min", method!(RubyMinMaxHeap::pop_min, -1))?;
     rb_c_min_max.define_method("empty?", method!(RubyMinMaxHeap::is_empty, 0))?;
-    rb_c_min_max.define_method("each", method!(RubyMinMaxHeap::each, 0))?;
-    rb_c_min_max.define_method("peek_min", method!(RubyMinMaxHeap::peek_min, 0))?;
-    rb_c_min_max.define_method("peek_max", method!(RubyMinMaxHeap::peek_max, 0))?;
-    rb_c_min_max.define_method("to_a", method!(RubyMinMaxHeap::to_a, 0))?;
-    rb_c_min_max.define_method("to_a_asc", method!(RubyMinMaxHeap::to_a_asc, 0))?;
-    rb_c_min_max.define_method("to_a_desc", method!(RubyMinMaxHeap::to_a_desc, 0))?;
+    rb_c_min_max.define_method("_each", method!(RubyMinMaxHeap::each, 0))?;
+    rb_c_min_max.define_method("_peek_min", method!(RubyMinMaxHeap::peek_min, 0))?;
+    rb_c_min_max.define_method("_peek_max", method!(RubyMinMaxHeap::peek_max, 0))?;
+    rb_c_min_max.define_method("_to_a_asc", method!(RubyMinMaxHeap::to_a_asc, 0))?;
+    rb_c_min_max.define_method("_to_a_desc", method!(RubyMinMaxHeap::to_a_desc, 0))?;
     rb_c_min_max.define_method("clear", method!(RubyMinMaxHeap::clear, 0))?;
     rb_c_min_max.define_method("size", method!(RubyMinMaxHeap::size, 0))?;
     rb_c_min_max.define_method("length", method!(RubyMinMaxHeap::size, 0))?;
-    rb_c_min_max.define_method("inspect", method!(RubyMinMaxHeap::inspect, 0))?;
     Ok(())
 }

data/lib/min_max/version.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
 class MinMax
-  VERSION = "0.1.2"
-
+  VERSION = "0.1.3"
 end

data/lib/min_max.rb

@@ -7,7 +7,26 @@ class MinMax
   class Error < StandardError; end
 
   def self.[](*args, &blk)
-    new(&blk).tap{|s| s.push(*args) }
+    new(*args, &blk)
+  end
+
+  def self.new(*args, &blk)
+    self._new.tap{|s|
+      s.priority_blk =(blk || proc{|x| (x.respond_to?(:priority) ? x.priority : x.to_i ) rescue 0})
+      s.push(*args)
+    }
+  end
+
+  def priority_blk=(bll)
+    @priority_blk = bll
+  end
+
+  def storage
+    @storage ||= Hash.new
+  end
+
+  def counts
+    @counts ||= Hash.new(0)
   end
 
   def mtx
@@ -15,19 +34,82 @@ class MinMax
   end
 
   def push(*args)
-    mtx.synchronize { _push(*args) }
+    mtx.synchronize do
+      mapped = args.map do |a|
+          counts[a.hash] += 1
+          storage[a.hash] = a
+          [
+            @priority_blk.call(a),
+            a.hash
+          ]
+      end
+       _push(mapped)
+    end
+    self
   end
 
   def add(*args)
-    mtx.synchronize { _push(*args) }
+    push(*args)
   end
 
   def pop_max(*args)
-    mtx.synchronize { _pop_max(*args) }
+    mtx.synchronize {
+      popped = _pop_max(*args)
+      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
+    }
   end
 
   def pop_min(*args)
-    mtx.synchronize { _pop_min(*args) }
+    mtx.synchronize {
+      popped = _pop_min(*args)
+      popped.kind_of?(Array) ? popped.map{|p| retrieve(p) } : retrieve(popped)
+    }
+  end
+
+  def retrieve(hash, remove=true)
+    if remove
+      if (counts[hash] -= 1) == 0
+        storage.delete(hash)
+      else
+        storage[hash]
+      end
+    else
+      storage[hash]
+    end
+  end
+
+  def peek_min(*args)
+    peeked = _peek_min(*args)
+    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  end
+
+  def peek_max(*args)
+    peeked = _peek_max(*args)
+    peeked.kind_of?(Array) ? peeked.map{|p| retrieve(p, false) } : retrieve(popped, false)
+  end
+
+  def each(*args, &blk)
+    if block_given?
+      mtx.synchronize { _each(*args).map{|p| blk[retrieve(p, false)] } }
+    else
+      to_enum(:each, *args)
+    end
+  end
+
+  def to_a
+    each.to_a
+  end
+
+  def to_a_asc
+    mtx.synchronize { _to_a_asc.map{|p| retrieve(p, false) } }
+  end
+
+  def to_a_desc
+    mtx.synchronize { _to_a_desc.map{|p| retrieve(p, false) } }
+  end
+
+  def inspect
+    "MinMax[#{to_a_asc.first(10).map{|v| v.to_s}.join(", ")}#{size > 10 ? ", ..." : ""}]"
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: min_max
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-24 00:00:00.000000000 Z
+date: 2024-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys