Queue/Definition: Difference between revisions

← Older edit Newer edit →

Content deleted Content added

Inline

@@ Line 2,138: / Line 2,138: @@
 =={{header|Ruby}}==
+The core class ''Array'' already implements all queue operations, so this class ''FIFO'' delegates everything to methods of ''Array''.
-<lang ruby>class FIFO
-  def initialize
+<lang ruby>require 'forwardable'
-    @fifo = []
+# A FIFO queue contains elements in first-in, first-out order.
+# FIFO#push adds new elements to the end of the queue;
+# FIFO#pop or FIFO#shift removes elements from the front.
+class FIFO
+  extend Forwardable
+  # Creates a FIFO containing _objects_.
+  def self.[](*objects)
+    new.push(*objects)
   end
+  # Creates an empty FIFO.
-  def push(*args)
+  def initialize; @ary = []; end
-    @fifo.push(*args)
+  # Appends _objects_ to the end of this FIFO. Returns self.
+  def push(*objects)
+    @ary.push(*objects)
     self
   end
@@ Line 2,150: / Line 2,164: @@
   alias enqueue push
+  ##
-  # popping an empty FIFO returns nil, or [] if a number is specified
-  def pop(*args)
+  # :method: pop
+  # :call-seq:
-    @fifo.shift(*args)
+  #   pop -> obj or nil
-  end
-  alias dequeue pop
+  #   pop(n) -> ary
+  #
+  # Removes an element from the front of this FIFO, and returns it.
-  def empty?
-    @fifo.empty?
+  # Returns nil if the FIFO is empty.
-  end
+  #
+  # If passing a number _n_, removes the first _n_ elements, and returns
+  # an Array of them. If this FIFO contains fewer than _n_ elements,
+  # returns them all. If this FIFO is empty, returns an empty Array.
+  def_delegator :@ary, :shift, :pop
+  alias shift pop
+  alias dequeue shift
+  ##
+  # :method: empty?
+  # Returns true if this FIFO contains no elements.
+  def_delegator :@ary, :empty?
+  ##
+  # :method: size
+  # Returns the number of elements in this FIFO.
+  def_delegator :@ary, :size
+  alias length size
+  # Converts this FIFO to a String.
-  def size
+  def to_s
-    @fifo.length
+    "FIFO#{@ary.inspect}"
   end
+  alias inspect to_s
-end
+end</lang>
-f = FIFO.new
+<lang ruby>f = FIFO.new
 f.empty?                           # => true
 f.pop                              # => nil
 f.pop(2)                           # => []
-f.push(14)                         # => #<FIFO:...>
+f.push(14)                         # => FIFO[14]
-f << "foo" << [1,2,3]              # => #<FIFO:...>
+f << "foo" << [1,2,3]              # => FIFO[14, "foo", [1, 2, 3]]
-f.enqueue("bar", Hash.new, "baz")  # => #<FIFO:...>
+f.enqueue("bar", Hash.new, "baz")
+# => FIFO[14, "foo", [1, 2, 3], "bar", {}, "baz"]
 f.size                             # => 6
 f.pop(3)                           # => [14, "foo", [1, 2, 3]]
 f.dequeue                          # => "bar"
-f.empty?                           # => false</lang>
+f.empty?                           # => false
+g = FIFO[:a, :b, :c]
+g.pop(2)                           # => [:a, :b]
+g.pop(2)                           # => [:c]
+g.pop(2)                           # => []</lang>
 =={{header|Scala}}==