Initial implementation of Concurrent::AtomicBoolean in pure Java.

Author: lucasallan

ext/ConcurrentRubyExtService.java

@@ -1,11 +1,12 @@
 import java.io.IOException;
-        
+
 import org.jruby.Ruby;
 import org.jruby.runtime.load.BasicLibraryService;
 
 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);
         return true;
     }
 }

ext/com/concurrent_ruby/ext/JavaAtomicBooleanLibrary.java

@@ -0,0 +1,96 @@
+package com.concurrent_ruby.ext;
+
+import java.io.IOException;
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+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.builtin.IRubyObject;
+import org.jruby.runtime.load.Library;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.jruby.RubyBoolean;
+import org.jruby.RubyNil;
+import org.jruby.runtime.ThreadContext;
+
+public class JavaAtomicBooleanLibrary implements Library {
+
+    public void load(Ruby runtime, boolean wrap) throws IOException {
+        RubyModule concurrentMod = runtime.defineModule("Concurrent");
+        RubyClass atomicCls = concurrentMod.defineClassUnder("JavaAtomicBoolean", runtime.getObject(), JRUBYREFERENCE_ALLOCATOR);
+        atomicCls.defineAnnotatedMethods(JavaAtomicBoolean.class);
+    }
+
+    private static final ObjectAllocator JRUBYREFERENCE_ALLOCATOR = new ObjectAllocator() {
+        public IRubyObject allocate(Ruby runtime, RubyClass klazz) {
+            return new JavaAtomicBoolean(runtime, klazz);
+        }
+    };
+
+    @JRubyClass(name = "JavaAtomicBoolean", parent = "Object")
+    public static class JavaAtomicBoolean extends RubyObject {
+
+        private AtomicBoolean atomicBoolean;
+        private ThreadContext context;
+
+        public JavaAtomicBoolean(Ruby runtime, RubyClass metaClass) {
+            super(runtime, metaClass);
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context, IRubyObject value) {
+            atomicBoolean = new AtomicBoolean(convertRubyBooleanToJavaBoolean(value));
+            this.context = context;
+            return context.nil;
+        }
+
+        @JRubyMethod
+        public IRubyObject initialize(ThreadContext context) {
+            atomicBoolean = new AtomicBoolean();
+            this.context = context;
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "value")
+        public IRubyObject value() {
+            return RubyBoolean.newBoolean(getRuntime(), atomicBoolean.get());
+        }
+
+        @JRubyMethod(name = "true?")
+        public IRubyObject isAtomicTrue() {
+            return RubyBoolean.newBoolean(getRuntime(), atomicBoolean.get());
+        }
+
+        @JRubyMethod(name = "false?")
+        public IRubyObject isAtomicFalse() {
+            return RubyBoolean.newBoolean(getRuntime(), (atomicBoolean.get() == false));
+        }
+
+        @JRubyMethod(name = "value=")
+        public IRubyObject setAtomic(IRubyObject newValue) {
+            atomicBoolean.set(convertRubyBooleanToJavaBoolean(newValue));
+            return context.nil;
+        }
+
+        @JRubyMethod(name = "make_true")
+        public IRubyObject makeTrue() {
+            return RubyBoolean.newBoolean(getRuntime(), atomicBoolean.compareAndSet(false, true));
+        }
+
+        @JRubyMethod(name = "make_false")
+        public IRubyObject makeFalse() {
+            return RubyBoolean.newBoolean(getRuntime(), atomicBoolean.compareAndSet(true, false));
+        }
+
+        private boolean convertRubyBooleanToJavaBoolean(IRubyObject newValue) {
+            if (newValue instanceof RubyBoolean.False || newValue instanceof RubyNil) {
+                return false;
+            } else {
+                return true;
+            }
+        }
+    }
+}
+

lib/concurrent/atomic/atomic_boolean.rb

@@ -115,49 +115,6 @@ def make_false
 
   if RUBY_PLATFORM == 'java'
 
-    # @!macro atomic_boolean
-    class JavaAtomicBoolean
-
-      # @!macro atomic_boolean_method_initialize
-      #
-      def initialize(initial = false)
-        @atomic = java.util.concurrent.atomic.AtomicBoolean.new(!!initial)
-      end
-
-      # @!macro atomic_boolean_method_value_get
-      #
-      def value
-        @atomic.get
-      end
-
-      # @!macro atomic_boolean_method_value_set
-      #
-      def value=(value)
-        @atomic.set(!!value)
-      end
-
-      # @!macro atomic_boolean_method_true_question
-      def true?
-        @atomic.get
-      end
-
-      # @!macro atomic_boolean_method_false_question
-      def false?
-        !@atomic.get
-      end
-
-      # @!macro atomic_boolean_method_make_true
-      def make_true
-        @atomic.compareAndSet(false, true)
-      end
-
-      # @!macro atomic_boolean_method_make_false
-      def make_false
-        @atomic.compareAndSet(true, false)
-      end
-    end
-
-    # @!macro atomic_boolean
     class AtomicBoolean < JavaAtomicBoolean
     end