LockFreeLinkedSet: use camel case and move node to correct namespace

Author: ianks

lib/concurrent/edge/lock_free_linked_set.rb

@@ -55,7 +55,7 @@ def add(item)
 
           node = Node.new item, curr
 
-          if pred.SuccessorReference.compare_and_set curr, node, false, false
+          if pred.Successor_reference.compare_and_set curr, node, false, false
             return true
           end
         end
@@ -88,7 +88,7 @@ def contains?(item)
 
         while curr < item
           curr = curr.next_node
-          marked = curr.SuccessorReference.marked?
+          marked = curr.Successor_reference.marked?
         end
 
         curr == item && !marked
@@ -109,11 +109,11 @@ def remove(item)
           return false if curr != item
 
           succ = curr.next_node
-          removed = curr.SuccessorReference.compare_and_set succ, succ, false, true
+          removed = curr.Successor_reference.compare_and_set succ, succ, false, true
 
           next_node unless removed
 
-          pred.SuccessorReference.compare_and_set curr, succ, false, false
+          pred.Successor_reference.compare_and_set curr, succ, false, false
 
           return true
         end
@@ -134,7 +134,7 @@ def each
 
         until curr.last?
           curr = curr.next_node
-          marked = curr.SuccessorReference.marked?
+          marked = curr.Successor_reference.marked?
 
           yield curr.Data unless marked
         end

lib/concurrent/edge/lock_free_linked_set/node.rb

@@ -6,12 +6,12 @@ class LockFreeLinkedSet
       class Node < Synchronization::Object
         include Comparable
 
-        attr_reader :Data, :SuccessorReference, :Key
+        attr_reader :Data, :Successor_reference, :Key
 
         def initialize(data = nil, successor = nil)
           super()
 
-          @SuccessorReference = AtomicMarkableReference.new(successor || Tail.new)
+          @Successor_reference = AtomicMarkableReference.new(successor || Tail.new)
           @Data = data
           @Key = key_for data
 
@@ -20,13 +20,13 @@ def initialize(data = nil, successor = nil)
 
         # Check to see if the node is the last in the list.
         def last?
-          @SuccessorReference.value.is_a? Tail
+          @Successor_reference.value.is_a? Tail
         end
 
         # Next node in the list. Note: this is not the AtomicMarkableReference
         # of the next node, this is the actual Node itself.
         def next_node
-          @SuccessorReference.value
+          @Successor_reference.value
         end
 
         # This method provides a unqiue key for the data which will be used for
@@ -49,7 +49,7 @@ def <=>(other)
       # a self-loop.
       class Tail < Node
         def initialize(_data = nil, _succ = nil)
-          @SuccessorReference = AtomicMarkableReference.new self
+          @Successor_reference = AtomicMarkableReference.new self
         end
 
         # Always greater than other nodes. This means that traversal will end

lib/concurrent/edge/lock_free_linked_set/window.rb

@@ -1,44 +1,46 @@
 module Concurrent
   module Edge
-    class Window
-      attr_accessor :pred, :curr
+    class LockFreeLinkedSet
+      class Window
+        attr_accessor :pred, :curr
 
-      def initialize(pred, curr)
-        @pred, @curr = pred, curr
-      end
-
-      # This method is used to find a 'window' for which `add` and `remove`
-      # methods can use to know where to add and remove from the list. However,
-      # it has another responsibilility, which is to physically unlink any
-      # nodes marked for removal in the set. This prevents adds/removes from
-      # having to retraverse the list to physically unlink nodes.
-      def self.find(head, item)
-        loop do
-          break_inner_loops = false
-          pred = head
-          curr = pred.next_node
+        def initialize(pred, curr)
+          @pred, @curr = pred, curr
+        end
 
+        # This method is used to find a 'window' for which `add` and `remove`
+        # methods can use to know where to add and remove from the list. However,
+        # it has another responsibilility, which is to physically unlink any
+        # nodes marked for removal in the set. This prevents adds/removes from
+        # having to retraverse the list to physically unlink nodes.
+        def self.find(head, item)
           loop do
-            succ, marked = curr.SuccessorReference.get
+            break_inner_loops = false
+            pred = head
+            curr = pred.next_node
 
-            # Remove sequence of marked nodes
-            while marked
-              removed = pred.SuccessorReference.compare_and_set curr, succ, false, false
+            loop do
+              succ, marked = curr.Successor_reference.get
 
-              # If could not remove node, try again
-              break_inner_loops = true && break unless removed
+              # Remove sequence of marked nodes
+              while marked
+                removed = pred.Successor_reference.compare_and_set curr, succ, false, false
 
-              curr = succ
-              succ, marked = curr.SuccessorReference.get
-            end
+                # If could not remove node, try again
+                break_inner_loops = true && break unless removed
+
+                curr = succ
+                succ, marked = curr.Successor_reference.get
+              end
 
-            break if break_inner_loops
+              break if break_inner_loops
 
-            # We have found a window
-            return new pred, curr if curr >= item
+              # We have found a window
+              return new pred, curr if curr >= item
 
-            pred = curr
-            curr = succ
+              pred = curr
+              curr = succ
+            end
           end
         end
       end