rufus-tokyo 0.1.7 → 0.1.8

data/lib/rufus/tokyo/cabinet/util.rb

@@ -31,332 +31,363 @@
 require 'rufus/tokyo/hmethods'
 
 
-module Rufus
-  module Tokyo
+module Rufus::Tokyo
+
+  #
+  # A Tokyo Cabinet in-memory (tcutil.h) map
+  #
+  # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+  #
+  class Map
+
+    include HashMethods
 
     #
-    # A Tokyo Cabinet in-memory (tcutil.h) map
+    # Creates an empty instance of a Tokyo Cabinet in-memory map
     #
-    # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+    # (It's OK to pass the pointer of a C map directly, this is in fact
+    # used in rufus/tokyo/table when retrieving entries)
     #
-    class Map
+    def initialize (pointer = nil)
+      @map = pointer || clib.tcmapnew
+    end
 
-      include HashMethods
+    #
+    # a shortcut
+    #
+    def clib
+      CabinetLib
+    end
 
-      #
-      # Creates an empty instance of a Tokyo Cabinet in-memory map
-      #
-      # (It's OK to pass the pointer of a C map directly, this is in fact
-      # used in rufus/tokyo/table when retrieving entries)
-      #
-      def initialize (pointer = nil)
-        @map = pointer || clib.tcmapnew
-      end
+    #
+    # Inserts key/value pair
+    #
+    def []= (k, v)
+      clib.tcmapput2(m, k, v)
+      v
+    end
 
-      #
-      # a shortcut
-      #
-      def clib
-        CabinetLib
-      end
+    #
+    # Deletes an entry
+    #
+    def delete (k)
+      v = self[k]
+      return nil unless v
+      (clib.tcmapout2(m, k) == 1) || raise("failed to remove key '#{k}'")
+      v
+    end
 
-      #
-      # Inserts key/value pair
-      #
-      def []= (k, v)
-        clib.tcmapput2(m, k, v)
-        v
-      end
+    #
+    # Empties the map
+    #
+    def clear
+      clib.tcmapclear(m)
+    end
 
-      #
-      # Deletes an entry
-      #
-      def delete (k)
-        v = self[k]
-        return nil unless v
-        (clib.tcmapout2(m, k) == 1) || raise("failed to remove key '#{k}'")
-        v
-      end
+    #
+    # (the actual #[] method is provided by HashMethods)
+    #
+    def get (k)
+      m; clib.tcmapget2(m, k) rescue nil
+    end
+    protected :get
 
-      #
-      # Empties the map
-      #
-      def clear
-        clib.tcmapclear(m)
-      end
+    #
+    # Returns an array of all the keys in the map
+    #
+    def keys
+      a = []
+      clib.tcmapiterinit(m)
+      while (k = (clib.tcmapiternext2(m) rescue nil)); a << k; end
+      a
+    end
 
-      #
-      # (the actual #[] method is provided by HashMethods)
-      #
-      def get (k)
-        m; clib.tcmapget2(m, k) rescue nil
-      end
-      protected :get
-
-      #
-      # Returns an array of all the keys in the map
-      #
-      def keys
-        a = []
-        clib.tcmapiterinit(m)
-        while (k = (clib.tcmapiternext2(m) rescue nil)); a << k; end
-        a
-      end
+    #
+    # Returns the count of entries in the map
+    #
+    def size
+      clib.tcmaprnum(m)
+    end
 
-      #
-      # Returns the count of entries in the map
-      #
-      def size
-        clib.tcmaprnum(m)
-      end
+    alias :length :size
+
+    #
+    # Frees the map (nukes it from memory)
+    #
+    def free
+      clib.tcmapdel(@map)
+      @map = nil
+    end
 
-      alias :length :size
+    alias :destroy :free
+    alias :close :free
 
-      #
-      # Frees the map (nukes it from memory)
-      #
-      def free
-        clib.tcmapdel(@map)
-        @map = nil
-      end
+    #
+    # Returns the pointer to the underlying Tokyo Cabinet map
+    #
+    def pointer
+      @map || raise('map got freed, cannot use anymore')
+    end
 
-      alias :destroy :free
-      alias :close :free
+    alias :m :pointer
 
-      #
-      # Returns the pointer to the underlying Tokyo Cabinet map
-      #
-      def pointer
-        @map || raise('map got freed, cannot use anymore')
-      end
+    #
+    # Turns a given Tokyo map structure into a Ruby Hash. By default
+    # (free = true) will dispose of the map before replying with the Ruby
+    # Hash.
+    #
+    def self.to_h (map_pointer, free=true)
+      m = self.new(map_pointer)
+      h = m.to_h
+      m.free if free
+      h
+    end
 
-      alias :m :pointer
-
-      #
-      # Turns a given Tokyo map structure into a Ruby Hash. By default
-      # (free = true) will dispose of the map before replying with the Ruby Hash.
-      #
-      def self.to_h (map_pointer, free = true)
-        m = self.new(map_pointer)
-        h = m.to_h
-        m.free if free
-        h
-      end
+    #
+    # Turns a Ruby hash into a Tokyo Cabinet Map and returns it
+    # (don't forget to free the map when you're done with it !)
+    #
+    def self.from_h (h)
+      h.inject(Map.new) { |m, (k, v)| m[k] = v; m }
+    end
+
+    #
+    # Behaves much like Hash#[] but outputs a Rufus::Tokyo::Map
+    # (don't forget to free the map when you're done with it !)
+    #
+    def self.[] (*h_or_a)
 
-      #
-      # Turns a Ruby hash into a Tokyo Cabinet Map and returns it
-      # (don't forget to free the map when you're done with it !)
-      #
-      def self.from_h (h)
-        h.inject(Map.new) { |m, (k, v)| m[k] = v; m }
+      if h_or_a.is_a?(Array) && h_or_a.size == 1 && h_or_a.first.is_a?(Array)
+        h_or_a = h_or_a.first
       end
 
-      #
-      # Behaves much like Hash#[] but outputs a Rufus::Tokyo::Map
-      # (don't forget to free the map when you're done with it !)
-      #
-      def self.[] (*h_or_a)
+      from_h(::Hash[*h_or_a])
+    end
+  end
 
-        if h_or_a.is_a?(Array) && h_or_a.size == 1 && h_or_a.first.is_a?(Array)
-          h_or_a = h_or_a.first
-        end
+  #
+  # A Tokyo Cabinet in-memory (tcutil.h) list
+  #
+  # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+  #
+  class List
+    include Enumerable
 
-        from_h(::Hash[*h_or_a])
+    #
+    # Creates a new Tokyo Cabinet list.
+    #
+    # (by passing a list pointer, one can wrap an existing list pointer
+    # into a handy instance of this class)
+    #
+    def initialize (list_pointer=nil)
+
+      if list_pointer.is_a?(FFI::Pointer)
+        @list = list_pointer
+      else
+        @list = clib.tclistnew
+        list_pointer.each { |e| self << e } if list_pointer
       end
     end
 
     #
-    # A Tokyo Cabinet in-memory (tcutil.h) list
+    # a shortcut
     #
-    # http://tokyocabinet.sourceforge.net/spex-en.html#tcutilapi
+    def clib
+      CabinetLib
+    end
+
     #
-    class List
-      include Enumerable
+    # Inserts an element in the list (note that the lib will raise an
+    # ArgumentError if s is not a String)
+    #
+    def << (s)
+      clib.tclistpush2(@list, s)
+      self
+    end
 
-      #
-      # Creates a new Tokyo Cabinet list.
-      #
-      # (by passing a list pointer, one can wrap an existing list pointer
-      # into a handy instance of this class)
-      #
-      def initialize (list_pointer=nil)
-        @list = list_pointer || clib.tclistnew
-      end
+    #
+    # Pushes an argument or a list of arguments to this list
+    #
+    def push (*args)
+      args.each { |a| self << a }
+      self
+    end
 
-      #
-      # a shortcut
-      #
-      def clib
-        CabinetLib
-      end
+    #
+    # Pops the last element in the list
+    #
+    def pop
+      clib.tclistpop2(@list) rescue nil
+    end
 
-      #
-      # Inserts an element in the list (note that the lib will raise an
-      # ArgumentError if s is not a String)
-      #
-      def << (s)
-        clib.tclistpush2(@list, s)
-        self
-      end
+    #
+    # Removes and returns the first element in a list
+    #
+    def shift
+      clib.tclistshift2(@list) rescue nil
+    end
 
-      #
-      # Pushes an argument or a list of arguments to this list
-      #
-      def push (*args)
-        args.each { |a| self << a }
-        self
-      end
+    #
+    # Inserts a string at the beginning of the list
+    #
+    def unshift (s)
+      clib.tclistunshift2(@list, s)
+      self
+    end
 
-      #
-      # Pops the last element in the list
-      #
-      def pop
-        clib.tclistpop2(@list) rescue nil
-      end
+    def []= (a, b, c=nil)
 
-      #
-      # Removes and returns the first element in a list
-      #
-      def shift
-        clib.tclistshift2(@list) rescue nil
-      end
+      i, s = c.nil? ? [ a, b ] : [ [a, b], c ]
+
+      range = if i.is_a?(Range)
+                i
+              elsif i.is_a?(Array)
+                start, count = i
+                (start..start + count - 1)
+              else
+                [ i ]
+              end
 
-      #
-      # Inserts a string at the beginning of the list
-      #
-      def unshift (s)
-        clib.tclistunshift2(@list, s)
-        self
+      range = norm(range)
+
+      values = s.is_a?(Array) ? s : [ s ]
+      # not "values = Array(s)"
+
+      range.each_with_index do |offset, index|
+        val = values[index]
+        if val
+          clib.tclistover2(@list, offset, val)
+        else
+          clib.tclistremove2(@list, values.size)
+        end
       end
 
-      def []= (a, b, c=nil)
+      self
+    end
 
-        i, s = c.nil? ? [ a, b ] : [ [a, b], c ]
+    #
+    # Removes the value at a given index and returns the value
+    # (returns nil if no value available)
+    #
+    def delete_at (i)
+      clib.tclistremove2(@list, i)
+    end
 
-        range = if i.is_a?(Range)
-                  i
-                elsif i.is_a?(Array)
-                  start, count = i
-                  (start..start + count - 1)
-                else
-                  [ i ]
-                end
+    def delete_if
+      # TODO
+    end
 
-        range = norm(range)
+    def slice
+      # TODO
+    end
+    def slice!
+      # TODO
+    end
 
-        values = s.is_a?(Array) ? s : [ s ]
-        # not "values = Array(s)"
+    #
+    # Returns the size of this Tokyo Cabinet list
+    #
+    def size
+      clib.tclistnum(@list)
+    end
 
-        range.each_with_index do |offset, index|
-          val = values[index]
-          if val
-            clib.tclistover2(@list, offset, val)
-          else
-            clib.tclistremove2(@list, values.size)
-          end
-        end
+    alias :length :size
 
-        self
-      end
+    #
+    # The equivalent of Ruby Array#[]
+    #
+    def [] (i, count=nil)
 
-      #
-      # Removes the value at a given index and returns the value
-      # (returns nil if no value available)
-      #
-      def delete_at (i)
-        clib.tclistremove2(@list, i)
-      end
+      return nil if (count != nil) && count < 1
 
-      def delete_if
-        # TODO
-      end
+      len = self.size
 
-      def slice
-        # TODO
-      end
-      def slice!
-        # TODO
-      end
+      range = if count.nil?
+                i.is_a?(Range) ? i : [i]
+              else
+                (i..i + count - 1)
+              end
 
-      #
-      # Returns the size of this Tokyo Cabinet list
-      #
-      def size
-        clib.tclistnum(@list)
-      end
+      r = norm(range).collect { |i| clib.tclistval2(@list, i) rescue nil }
 
-      alias :length :size
+      range.first == range.last ? r.first : r
+    end
 
-      #
-      # The equivalent of Ruby Array#[]
-      #
-      def [] (i, count=nil)
+    def clear
+      clib.tclistclear(@list)
+    end
 
-        return nil if (count != nil) && count < 1
+    def each
+      (0..self.size - 1).each { |i| yield self[i] }
+    end
 
-        len = self.size
+    #
+    # Turns this Tokyo Cabinet list into a Ruby array
+    #
+    def to_a
+      self.collect { |e| e }
+    end
 
-        range = if count.nil?
-                  i.is_a?(Range) ? i : [i]
-                else
-                  (i..i + count - 1)
-                end
+    #
+    # Closes (frees) this list
+    #
+    def free
+      self.class.free(@list)
+      @list = nil
+    end
 
-        r = norm(range).collect { |i| clib.tclistval2(@list, i) rescue nil }
+    alias :close :free
+    alias :destroy :free
 
-        range.first == range.last ? r.first : r
-      end
+    #
+    # Frees (closes) the given 'native' (FFI) list (memory pointer)
+    #
+    def self.free (list_pointer)
 
-      def clear
-        clib.tclistclear(@list)
-      end
+      CabinetLib.tclistdel(list_pointer)
+    end
 
-      def each
-        (0..self.size - 1).each { |i| yield self[i] }
-      end
+    #
+    # Closes (frees memory from it) this list and returns the ruby version
+    # of it
+    #
+    def release
 
-      #
-      # Turns this Tokyo Cabinet list into a Ruby array
-      #
-      def to_a
-        self.collect { |e| e }
-      end
+      a = self.to_a
+      self.close
+      a
+    end
 
-      #
-      # Closes (frees) this list
-      #
-      def close
-        clib.tclistdel(@list)
-        @list = nil
-      end
+    #
+    # Returns the underlying 'native' (FFI) memory pointer
+    #
+    def pointer
+
+      @list
+    end
 
-      alias :free :close
-      alias :destroy :close
+    #
+    # Turns a list pointer into a Ruby Array instance (and makes sure to
+    # release the pointer
+    #
+    def self.release (list_pointer)
 
-      #
-      # Closes (frees memory from it) this list and returns the ruby version
-      # of it
-      #
-      def release
+      Rufus::Tokyo::List.new(list_pointer).release
+    end
 
-        a = self.to_a
-        self.close
-        a
-      end
+    protected
 
-      protected
-
-      #
-      # Makes sure this offset/range fits the size of the list
-      #
-      def norm (i)
-        l = self.length
-        case i
-        when Range then ((i.first % l)..(i.last % l))
-        when Array then [ i.first % l ]
-        else i % l
-        end
+    #
+    # Makes sure this offset/range fits the size of the list
+    #
+    def norm (i)
+      l = self.length
+      case i
+      when Range then ((i.first % l)..(i.last % l))
+      when Array then [ i.first % l ]
+      else i % l
       end
     end
   end
 end
+