unified-queues 0.1.0

data/lib/unified-queues/single.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "unified-queues/single/driver"
+require "hash-utils/module"
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # Universal single queue interface.
+    #
+    
+    class Single
+        
+        ##
+        # Contains assignment of classnames to drivers.
+        # @return [Hash] 
+        #
+          
+        DRIVERS = Hash[
+            :Queue => "queue",
+            :Array => "array",
+            :Depq => "depq",
+            :"Containers::Heap" => "algorithms",
+            :CPriorityQueue => "priority_queue",
+            :PoorPriorityQueue => "priority_queue",
+            :RubyPriorityQueue => "priority_queue",
+            :EventedQueue => "evented-queue" 
+        ]
+        
+        ##
+        # Contains driver for specific class instance.
+        # @return [UnifiedQueues::Single::Driver] driver instance
+        #
+
+        attr_accessor :driver
+        @driver
+        
+        ##
+        # Constructor.
+        #
+        # @param [Class|UnifiedQueues::Single::Driver] cls  required class object or driver instance
+        # @param [Array] *args  array of arguments for the queue constructor
+        # @param [Proc] &block  block for the queue constructor
+        #
+      
+        def initialize(cls, *args, &block)
+            if cls.kind_of? UnifiedQueues::Single::Driver
+                @driver = cls
+            else
+                self.assign_driver(cls, args, block)
+            end
+        end
+        
+        ##
+        # Assigns driver to interface according to given class name.
+        #
+        # @param [Class] cls  required class
+        # @param [Array] args  array of arguments for the queue constructor
+        # @param [Proc] block  block for the queue constructor
+        # @return [UnifiedQueues::Single::Driver] new driver instance
+        # 
+        
+        def assign_driver(cls, args, block)
+            _cls = cls
+            if not _cls.kind_of? Class
+                _cls = cls.class
+            end
+            
+            driver = nil
+            name = nil
+            
+            self.class::DRIVERS.each_pair do |_name, _driver|
+                begin
+                    _module = Module::get_module(_name.to_s)
+                rescue NameError
+                    next
+                end
+                
+                if _cls <= _module
+                    driver = _driver
+                    name = _name
+                    break
+                end
+            end
+            
+            ###
+            
+            require "unified-queues/single/driver/" << driver
+            
+            path = name.to_s.split("::")
+            classname = path.shift << 'Driver::' << path.join('::')
+            _module = Module::get_module("UnifiedQueues::Single::Driver::" << classname)
+            
+            args = [cls] + args
+            @driver = _module::new(*args, &block)
+            return @driver
+        end
+        
+        ##
+        # Pushes the value into the queue.
+        #
+        # @param [Object] value  value for push
+        # @param [Object] key  key for priority queues
+        #
+        
+        def push(value, key = value, &block)
+            @driver.push(value, key, &block)
+        end
+        
+        alias :<< :push
+        
+        ##
+        # Pops value out of the queue.
+        #
+        # @param [Boolean|Integer] blocking  +true+ or timeout if it should block, +false+ otherwise
+        # @param [Object] queue value
+        #
+        
+        def pop(blocking = false, &block)
+            @driver.pop(blocking, &block)
+        end
+        
+        alias :pop! :pop
+        
+        ##
+        # Indicates queue is empty.
+        # @param [Boolean] +true+ if it's, +false+ otherwise
+        #
+        
+        def empty?(&block)
+            @driver.empty?(&block)
+        end
+        
+        ##
+        # Clears the queue.
+        #
+      
+        def clear!(&block)
+            @driver.clear!(&block)
+        end
+        
+        alias :clear :clear! 
+        
+        ##
+        # Returns length of the queue.
+        # @return [Integer]
+        #
+        
+        def length(&block)
+            @driver.length(&block)
+        end
+        
+        alias :size :length
+        
+=begin
+        protected
+        
+        ##
+        # Returns value using yield or return according to driver settings.
+        #
+        # @return [Object]  returned value
+        # @yield [Object] returned value
+        #
+        
+        def __return
+            if @driver.linear?
+              
+            end
+        end
+=end
+    end
+end
+

data/lib/unified-queues/single/driver.rb

@@ -0,0 +1,147 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "abstract"
+
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # Universal single queue interface.
+    #
+    
+    class Single
+      
+        ##
+        # Abstract single driver class.
+        # @abstract
+        #
+        
+        class Driver
+          
+            ##
+            # Holds native object.
+            # @return [Object]
+            #
+            
+            attr_accessor :native
+            @native
+            
+            ##
+            # Constructor.
+            #
+            
+            def initialize(cls, *args, &block)
+                if self.instance_of? UnifiedQueues::Single::Driver
+                    not_implemented
+                end
+                
+                if cls.kind_of? Class
+                    @native = cls::new(*args, &block)
+                else
+                    @native = cls
+                end
+            end
+            
+            ##
+            # Pushes the value into the queue.
+            #
+            # @param [Object] value  value for push
+            # @param [Object] key  key for priority queues
+            # @abstract
+            #
+            
+            def push(value, key = value, &block)
+                not_implemented
+            end
+            
+            alias :<< :push
+            
+            ##
+            # Pops value out of the queue.
+            #
+            # @param [Boolean|Integer] blocking  +true+ or timeout if it should block, +false+ otherwise
+            # @param [Object] queue value
+            # @abstract
+            #
+            
+            def pop(blocking = false, &block)
+                not_implemented
+            end
+            
+            ##
+            # Indicates queue is empty.
+            #
+            # @param [Boolean] +true+ if it's, +false+ otherwise
+            # @abstract
+            #
+            
+            def empty?(&block)
+                not_implemented
+            end
+            
+            ##
+            # Clears the queue.
+            # @abstract
+            #
+          
+            def clear!(&block)
+                while not self.pop.nil?
+                end
+            end 
+            
+            alias :clear :clear! 
+            
+            ##
+            # Returns length of the queue.
+            #
+            # @return [Integer]
+            # @abstract
+            #
+            
+            def length(&block)
+                not_implemented
+            end
+            
+            alias :size :length
+            
+            ##
+            # Returs type of the queue. Queue can be +:linear+ which means,
+            # calls values are returned using +return+ or +:evented+
+            # which indicates necessity of callbacks.
+            #
+            # @return [:linear, :evented]
+            # @abstract
+            #
+            
+            def type
+                not_implemented
+            end 
+            
+            ##
+            # Indicates, driver is evented so expexts callbacks.
+            # @return [Boolean] +true+ if it is, +false+ otherwise
+            # 
+            
+            def evented?
+                self.type == :evented
+            end
+            
+            ##
+            # Indicates, driver is evented so expexts callbacks.
+            # @return [Boolean] +true+ if it is, +false+ otherwise
+            # 
+            
+            def linear?
+                self.type == :linear
+            end
+            
+        end
+        
+    end
+    
+end

data/lib/unified-queues/single/driver/algorithms.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "unified-queues/single/driver"
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # Universal single queue interface.
+    #
+    
+    class Single
+      
+        ##
+        # Abstract single driver class.
+        # @abstract
+        #
+        
+        class Driver
+          
+            ##
+            # Wrapper according to +algorithm+ library.
+            #
+            
+            module ContainersDriver
+              
+                ##
+                # Fibonacci heap queue driver. Uses the +Containers::Heap+ 
+                # class from +algorithms+ gem for queueing. Priority is supported.
+                #
+                
+                class Heap < Driver
+                    
+                    ##
+                    # Pushes the value into the queue. Priority is supported.
+                    #
+                    # @param [Object] value  value for push
+                    # @param [Object] key  key for priority queues
+                    #
+                    
+                    def push(value, key = value)
+                        @native.push(key, value)
+                    end
+                    
+                    ##
+                    # Pops value out of the queue. Note, value with minimal 
+                    # priority will be popped out. Blocking isn'ŧ supported.
+                    #
+                    # @param [Boolean|Integer] blocking  +true+ or timeout if it should block, +false+ otherwise
+                    # @return [Object] queued value
+                    #
+                    
+                    def pop(blocking = false)
+                        @native.pop
+                    end
+                    
+                    ##
+                    # Indicates queue is empty.
+                    # @param [Boolean] +true+ if it's, +false+ otherwise
+                    #
+                    
+                    def empty?
+                        @native.empty?
+                    end
+                    
+                    ##
+                    # Clears the queue.
+                    #
+                  
+                    def clear!
+                        @native.clear
+                    end
+                    
+                    ##
+                    # Returns length of the queue.
+                    # @return [Integer]
+                    #
+                    
+                    def length
+                        @native.size
+                    end
+                    
+                    ##
+                    # Returs type of the queue.
+                    # @return [:linear]
+                    #
+                    
+                    def type
+                        :linear
+                    end
+                    
+                end
+            end
+        end
+    end
+end

data/lib/unified-queues/single/driver/array.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+# (c) 2011 Martin Kozák (martinkozak@martinkozak.net)
+
+require "unified-queues/single/driver"
+
+##
+# Base +Unified Queues+ module.
+#
+
+module UnifiedQueues
+  
+    ##
+    # Universal single queue interface.
+    #
+    
+    class Single
+      
+        ##
+        # Abstract single driver class.
+        # @abstract
+        #
+        
+        class Driver
+          
+            ##
+            # Array queue driver. Uses standard library +Array+ class
+            # for queueing. Priority isn't supported.
+            #
+            
+            class ArrayDriver < Driver
+                
+                ##
+                # Pushes the value into the queue. Priority isn't supported.
+                #
+                # @param [Object] value  value for push
+                # @param [Object] key  key for priority queues
+                #
+                
+                def push(value, key = value)
+                    @native.push(value)
+                end
+                
+                ##
+                # Pops value out of the queue. Blocking isn'ŧ supported.
+                #
+                # @param [Boolean|Integer] blocking  +true+ or timeout if it should block, +false+ otherwise
+                # @return [Object] out-queued value
+                #
+                
+                def pop(blocking = false)
+                    @native.shift
+                end
+                
+                ##
+                # Indicates queue is empty.
+                # @param [Boolean] +true+ if it's, +false+ otherwise
+                #
+                
+                def empty?
+                    @native.empty?
+                end
+                
+                ##
+                # Clears the queue.
+                #
+              
+                def clear!
+                    @native.clear
+                end
+                
+                ##
+                # Returns length of the queue.
+                # @return [Integer]
+                #
+                
+                def length
+                    @native.length
+                end
+                
+                ##
+                # Returs type of the queue.
+                # @return [:linear]
+                #
+                
+                def type
+                    :linear
+                end
+                                
+            end
+        end
+        
+    end
+    
+end