Implements Concurrent::AtomicFixnum in pure Java.

Author: lucasallan

ext/ConcurrentRubyExtService.java

@@ -7,6 +7,7 @@ public class ConcurrentRubyExtService implements BasicLibraryService {
     public boolean basicLoad(final Ruby runtime) throws IOException {
         new com.concurrent_ruby.ext.AtomicReferenceLibrary().load(runtime, false);
         new com.concurrent_ruby.ext.JavaAtomicBooleanLibrary().load(runtime, false);
+        new com.concurrent_ruby.ext.JavaAtomicFixnumLibrary().load(runtime, false);
         return true;
     }
 }

ext/com/concurrent_ruby/ext/JavaAtomicFixnumLibrary.java

@@ -0,0 +1,94 @@
+package com.concurrent_ruby.ext;
+
+import java.io.IOException;
+import java.util.concurrent.atomic.AtomicLong;
+import org.jruby.Ruby;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+
+public class JavaAtomicFixnumLibrary implements Library {
+
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicFixnum", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+
+        atomicCls.defineAnnotatedMethods(JavaAtomicFixnum.class);
+
+    }
+
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JavaAtomicFixnum(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name = "JavaAtomicFixnum", parent = "Object")
+    public static class JavaAtomicFixnum extends RubyObject {
+
+        private AtomicLong atomicLong;
+        private ThreadContext context;
+
+        public JavaAtomicFixnum(Ruby runtime, RubyClass metaClass) {
+            super(runtime, metaClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            this.atomicLong = new AtomicLong(0);
+            this.context = context;
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            this.atomicLong = new AtomicLong(rubyFixnumToLong(value));
+            this.context = context;
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "value")
+        public IRubyObject getValue() {
+            return new RubyFixnum(getRuntime(), atomicLong.get());
+        }
+
+        @JRubyMethod(name = "value=")
+        public IRubyObject setValue(IRubyObject newValue) {
+            atomicLong.set(rubyFixnumToLong(newValue));
+            return context.nil;
+        }
+
+        @JRubyMethod(name = {"increment", "up"})
+        public IRubyObject increment() {
+            return new RubyFixnum(getRuntime(), atomicLong.incrementAndGet());
+        }
+
+        @JRubyMethod(name = {"decrement", "down"})
+        public IRubyObject decrement() {
+            return new RubyFixnum(getRuntime(), atomicLong.decrementAndGet());
+        }
+
+        @JRubyMethod(name = "compare_and_set")
+        public IRubyObject compareAndSet(IRubyObject expect, IRubyObject update) {
+            return RubyBoolean.newBoolean(getRuntime(), atomicLong.compareAndSet(rubyFixnumToLong(expect), rubyFixnumToLong(update)));
+        }
+
+        private long rubyFixnumToLong(IRubyObject value) {
+            if (value instanceof RubyFixnum) {
+                RubyFixnum fixNum = (RubyFixnum) value;
+                return fixNum.getLongValue();
+            } else {
+                throw getRuntime().newArgumentError("initial value must be a Fixnum");
+            }
+        }
+    }
+}
+

lib/concurrent/atomic/atomic_fixnum.rb

@@ -97,14 +97,14 @@ def decrement
     alias_method :down, :decrement
 
     # @!macro [attach] atomic_fixnum_method_compare_and_set
-    # 
+    #
     #   Atomically sets the value to the given updated value if the current
     #   value == the expected value.
     #
     #   @param [Fixnum] expect the expected value
     #   @param [Fixnum] update the new value
     #
-    #   @return [Boolean] true if the value was updated else false 
+    #   @return [Boolean] true if the value was updated else false
     def compare_and_set(expect, update)
       @mutex.lock
       if @value == expect
@@ -120,47 +120,6 @@ def compare_and_set(expect, update)
 
   if RUBY_PLATFORM == 'java'
 
-    # @!macro atomic_fixnum
-    class JavaAtomicFixnum
-
-      MIN_VALUE = Java::JavaLang::Long::MIN_VALUE
-      MAX_VALUE = Java::JavaLang::Long::MAX_VALUE
-
-      # @!macro atomic_fixnum_method_initialize
-      def initialize(init = 0)
-        raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
-        @atomic = java.util.concurrent.atomic.AtomicLong.new(init)
-      end
-
-      # @!macro atomic_fixnum_method_value_get
-      def value
-        @atomic.get
-      end
-
-      # @!macro atomic_fixnum_method_value_set
-      def value=(value)
-        raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
-        @atomic.set(value)
-      end
-
-      # @!macro atomic_fixnum_method_increment
-      def increment
-        @atomic.increment_and_get
-      end
-      alias_method :up, :increment
-
-      # @!macro atomic_fixnum_method_decrement
-      def decrement
-        @atomic.decrement_and_get
-      end
-      alias_method :down, :decrement
-
-      # @!macro atomic_fixnum_method_compare_and_set
-      def compare_and_set(expect, update)
-        @atomic.compare_and_set(expect, update)
-      end
-    end
-
     # @!macro atomic_fixnum
     class AtomicFixnum < JavaAtomicFixnum
     end