Added AtomicBoolean class

Author: jdantonio

lib/concurrent/atomic/atomic_boolean.rb

@@ -0,0 +1,136 @@
+module Concurrent
+
+  # @!macro [attach] atomic_boolean
+  #
+  #   A boolean value that can be updated atomically. Reads and writes to an atomic
+  #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
+  #   briefly but no explicit locking is required.
+  #
+  #   @since 0.6.0
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
+  class MutexAtomicBoolean
+
+    # @!macro [attach] atomic_boolean_method_initialize
+    #
+    # Creates a new `AtomicBoolean` with the given initial value.
+    #
+    # @param [Boolean] init the initial value
+    def initialize(initial = false)
+      @value = !! initial
+      @mutex = Mutex.new
+    end
+
+    # @!macro [attach] atomic_boolean_method_value
+    #
+    #   Retrieves the current `Boolean` value.
+    #
+    #   @return [Boolean] the current value
+    def value
+      @mutex.synchronize{ @value }
+    end
+
+    # @!macro [attach] atomic_boolean_method_value_eq
+    #
+    #   Explicitly sets the value.
+    #
+    #   @param [Boolean] value the new value to be set
+    #
+    #   @return [Boolean] the current value
+    def value=(value)
+      @mutex.synchronize{ @value = !! value }
+    end
+
+    # @!macro [attach] atomic_boolean_method_is_true
+    #
+    #   Is the current value `true`?
+    #
+    #   @return [Boolean] true if the current value is `true`, else false
+    def true?
+      @mutex.synchronize{ @value == true }
+    end
+
+    # @!macro [attach] atomic_boolean_method_is_false
+    #
+    #   Is the current value `true`?false
+    #
+    #   @return [Boolean] true if the current value is `false`, else false
+    def false?
+      @mutex.synchronize{ @value != true }
+    end
+
+    # @!macro [attach] atomic_boolean_method_make_true
+    #
+    #   Explicitly sets the value to true.
+    #
+    #   @return [Boolean] the current value
+    def make_true
+      @mutex.synchronize{ @value = true }
+      nil
+    end
+
+    # @!macro [attach] atomic_boolean_method_make_false
+    #
+    #   Explicitly sets the value to false.
+    #
+    #   @return [Boolean] the current value
+    def make_false
+      @mutex.synchronize{ @value = false }
+      nil
+    end
+  end
+
+  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
+      #
+      def value
+        @atomic.get
+      end
+
+      # @!macro atomic_boolean_method_value_eq
+      #
+      def value=(value)
+        @atomic.set(!! value)
+      end
+
+      # @!macro [attach] atomic_boolean_method_is_true
+      def true?
+        @atomic.get == true
+      end
+
+      # @!macro [attach] atomic_boolean_method_is_false
+      def false?
+        @atomic.get != true
+      end
+
+      # @!macro atomic_boolean_method_make_true
+      def make_true
+        @atomic.set(true)
+      end
+
+      # @!macro atomic_boolean_method_make_false
+      def make_false
+        @atomic.set(false)
+      end
+    end
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < JavaAtomicBoolean
+    end
+
+  else
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < MutexAtomicBoolean
+    end
+  end
+end

lib/concurrent/atomics.rb

@@ -1,3 +1,4 @@
+require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/atomic/condition'
 require 'concurrent/atomic/copy_on_notify_observer_set'

spec/concurrent/atomic/atomic_boolean_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+share_examples_for :atomic_boolean do
+
+  context 'construction' do
+
+    it 'sets the initial value' do
+      described_class.new(true).value.should be_true
+    end
+
+    it 'defaults the initial value to false' do
+      described_class.new.value.should be_false
+    end
+
+    it 'evaluates the truthiness of a true value' do
+      described_class.new(10).value.should be_true
+    end
+
+    it 'evaluates the truthiness of a false value' do
+      described_class.new(nil).value.should be_false
+    end
+  end
+
+  context '#value' do
+
+    it 'returns the current value' do
+      counter = described_class.new(true)
+      counter.value.should be_true
+      counter.make_false
+      counter.value.should be_false
+      counter.make_true
+      counter.value.should be_true
+    end
+  end
+
+  context '#value=' do
+
+    it 'sets the #value to the given `Boolean`' do
+      atomic = described_class.new(true)
+      atomic.value = false
+      atomic.value.should be_false
+    end
+
+    it 'returns the new value' do
+      atomic = described_class.new(false)
+      (atomic.value = true).should be_true
+    end
+
+    it 'evaluates the truthiness of a true value' do
+      atomic = described_class.new(false)
+      atomic.value = 10
+      atomic.value.should be_true
+    end
+
+    it 'evaluates the truthiness of a false value' do
+      atomic = described_class.new(true)
+      atomic.value = nil
+      atomic.value.should be_false
+    end
+  end
+
+  context 'true?' do
+
+    specify { described_class.new(true).true?.should be_true }
+
+    specify { described_class.new(false).true?.should be_false }
+  end
+
+  context 'false?' do
+
+    specify { described_class.new(true).false?.should be_false }
+
+    specify { described_class.new(false).false?.should be_true }
+  end
+
+  context 'make_true' do
+
+    it 'makes a false value true and returns nil' do
+      subject = described_class.new(false)
+      subject.make_true.should be_nil
+      subject.value.should be_true
+    end
+
+    it 'keeps a true value true and returns nil' do
+      subject = described_class.new(true)
+      subject.make_true.should be_nil
+      subject.value.should be_true
+    end
+  end
+
+  context 'make_false' do
+
+    it 'makes a true value false and returns nil' do
+      subject = described_class.new(true)
+      subject.make_false.should be_nil
+      subject.value.should be_false
+    end
+
+    it 'keeps a false value false and returns nil' do
+      subject = described_class.new(false)
+      subject.make_false.should be_nil
+      subject.value.should be_false
+    end
+  end
+end
+
+module Concurrent
+
+  describe MutexAtomicBoolean do
+
+    it_should_behave_like :atomic_boolean
+
+    specify 'construction is synchronized' do
+      mutex = double('mutex')
+      Mutex.should_receive(:new).once.with(no_args).and_return(mutex)
+      described_class.new
+    end
+
+    specify 'value is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:synchronize)
+      described_class.new.value
+    end
+
+    specify 'value= is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:synchronize)
+      described_class.new.value = 10
+    end
+
+    specify 'true? is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:synchronize)
+      described_class.new.true?
+    end
+
+    specify 'false? is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:synchronize)
+      described_class.new.false?
+    end
+
+    specify 'make_true is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:synchronize)
+      described_class.new.make_true
+    end
+
+    specify 'make_false is synchronized' do
+      mutex = double('mutex')
+      Mutex.stub(:new).with(no_args).and_return(mutex)
+      mutex.should_receive(:synchronize)
+      described_class.new.make_false
+    end
+  end
+
+  if jruby?
+
+    describe JavaAtomicBoolean do
+      it_should_behave_like :atomic_boolean
+    end
+  end
+
+  describe AtomicBoolean do
+    if jruby?
+      it 'inherits from JavaAtomicBoolean' do
+        AtomicBoolean.ancestors.should include(JavaAtomicBoolean)
+      end
+    else
+      it 'inherits from MutexAtomicBoolean' do
+        AtomicBoolean.ancestors.should include(MutexAtomicBoolean)
+      end
+    end
+  end
+end