oklahoma_mixer 0.1.0 → 0.2.0

data/lib/oklahoma_mixer/fixed_length_database/c.rb

@@ -0,0 +1,62 @@
+module OklahomaMixer
+  class FixedLengthDatabase < HashDatabase
+    module C  # :nodoc:
+      extend OklahomaMixer::Utilities::FFIDSL
+      
+      IDS = enum :FDBIDMIN,  -1,
+                 :FDBIDPREV, -2,
+                 :FDBIDMAX,  -3,
+                 :FDBIDNEXT, -4
+
+      prefix :tcfdb
+      
+      def_core_database_consts_and_funcs
+
+      func :name    => :tune,
+           :args    => [:pointer, :int32, :int64],
+           :returns => :bool
+      func :name    => :optimize,
+           :args    => [:pointer, :int32, :int64],
+           :returns => :bool
+
+      func :name    => :put,
+           :args    => [:pointer, :int64, :pointer, :int],
+           :returns => :bool
+      func :name    => :putkeep,
+           :args    => [:pointer, :int64, :pointer, :int],
+           :returns => :bool
+      func :name    => :putcat,
+           :args    => [:pointer, :int64, :pointer, :int],
+           :returns => :bool
+      call :name    => :TCPDPROC,
+           :args    => [:pointer, :int, :pointer, :pointer],
+           :returns => :pointer
+      func :name    => :putproc,
+           :args    => [:pointer, :int64, :pointer, :int, :TCPDPROC, :pointer],
+           :returns => :bool
+      func :name    => :addint,
+           :args    => [:pointer, :int64, :int],
+           :returns => :int
+      func :name    => :adddouble,
+           :args    => [:pointer, :int64, :double],
+           :returns => :double
+      func :name    => :out,
+           :args    => [:pointer, :int64],
+           :returns => :bool
+      func :name    => :get,
+           :args    => [:pointer, :int64, :pointer],
+           :returns => :pointer
+
+      func :name    => :iterinit,
+           :args    => :pointer,
+           :returns => :bool
+      func :name    => :iternext,
+           :args    => :pointer,
+           :returns => :uint64
+
+      func :name    => :range,
+           :args    => [:pointer, :int64, :int64, :int, :pointer],
+           :returns => :pointer
+    end
+  end
+end

data/lib/oklahoma_mixer/hash_database.rb

@@ -4,17 +4,17 @@ module OklahomaMixer
     ### Constants ###
     #################
     
-    MODES = { "r" => :HDBOREADER,
-              "w" => :HDBOWRITER,
-              "c" => :HDBOCREAT,
-              "t" => :HDBOTRUNC,
-              "e" => :HDBONOLCK,
-              "f" => :HDBOLCKNB,
-              "s" => :HDBOTSYNC }
-    OPTS  = { "l" => :HDBTLARGE,
-              "d" => :HDBTDEFLATE,
-              "b" => :HDBTBZIP,
-              "t" => :HDBTTCBS }
+    MODES = { "r" => :OREADER,
+              "w" => :OWRITER,
+              "c" => :OCREAT,
+              "t" => :OTRUNC,
+              "e" => :ONOLCK,
+              "f" => :OLCKNB,
+              "s" => :OTSYNC }
+    OPTS  = { "l" => :TLARGE,
+              "d" => :TDEFLATE,
+              "b" => :TBZIP,
+              "t" => :TTCBS }
     
     ###################
     ### File System ###
@@ -24,24 +24,20 @@ module OklahomaMixer
       options              = args.last.is_a?(Hash)   ? args.last  : { }
       mode                 = !args.first.is_a?(Hash) ? args.first : nil
       @path                = path
-      @db                  = C.new
+      @db                  = lib.new
       self.default         = options[:default]
       @in_transaction      = false
       @abort               = false
       @nested_transactions = options[:nested_transactions]
       
       try(:setmutex) if options[:mutex]
-      if options.values_at(:bnum, :apow, :fpow, :opts).any?
-        optimize(options.merge(:tune => true))
-      end
-      {:rcnum => :cache, :xmsiz => nil, :dfunit => nil}.each do |option, func|
-        if i = options[option]
-          try("set#{func || option}", i.to_i)
-        end
-      end
+      tune(options)
       
       warn "mode option supersedes mode argument" if mode and options[:mode]
       try(:open, path, to_enum_int(options.fetch(:mode, mode || "wc"), :mode))
+    rescue Exception
+      close if defined?(@db) and @db
+      raise
     end
     
     def optimize(options)
@@ -55,7 +51,7 @@ module OklahomaMixer
     attr_reader :path
     
     def file_size
-      C.fsiz(@db)
+      lib.fsiz(@db)
     end
     
     def flush
@@ -94,35 +90,37 @@ module OklahomaMixer
     end
     
     def store(key, value, mode = nil)
-      k, v   = key.to_s, value.to_s
+      k      = cast_key_in(key)
+      v      = cast_value_in(value) unless mode == :add and not block_given?
       result = value
       if block_given?
         warn "block supersedes mode argument" unless mode.nil?
         callback = lambda { |old_value_pointer, old_size, returned_size, _|
-          old_value   = old_value_pointer.get_bytes(0, old_size)
-          replacement = yield(key, old_value, value).to_s
-          returned_size.put_int(0, replacement.size)
-          FFI::MemoryPointer.from_string(replacement)
+          old_value         = old_value_pointer.get_bytes(0, old_size)
+          replacement, size = cast_value_in(yield(key, old_value, value))
+          returned_size.put_int(0, size)
+          pointer = Utilities.malloc(size)
+          pointer.put_bytes(0, replacement) unless pointer.address.zero?
+          pointer
         }
-        try(:putproc, k, k.size, v, v.size, callback, nil)
+        try(:putproc, k, v, callback, nil)
       else
-        case mode
-        when :keep
-          result = try( :putkeep, k, k.size, v, v.size,
-                        :no_error => {21 => false} )
-        when :cat
-          try(:putcat, k, k.size, v, v.size)
-        when :async
-          try(:putasync, k, k.size, v, v.size)
-        when :add
+        if mode == :keep
+          result = try(:putkeep, k, v, :no_error => {21 => false})
+        elsif mode == :cat
+          try(:putcat, k, v)
+        elsif mode == :async and self.class == HashDatabase
+          try(:putasync, k, v)
+        elsif mode == :add
           result = case value
-                   when Float then try( :adddouble, k, k.size, value,
+                   when Float then try( :adddouble, k, value,
                                         :failure => lambda { |n| n.nan? } )
-                   else            try( :addint, k, k.size, value.to_i,
+                   else            try( :addint, k, value.to_i,
                                         :failure => Utilities::INT_MIN )
                    end
         else
-          try(:put, k, k.size, v, v.size)
+          warn "unsupported mode for database type" if mode
+          try(:put, k, v)
         end
       end
       result
@@ -130,8 +128,7 @@ module OklahomaMixer
     alias_method :[]=, :store
     
     def fetch(key, *default)
-      k        = key.to_s
-      if value = try( :read_from_func, :get, k, k.size,
+      if value = try( :read_from_func, :get, cast_key_in(key),
                       :failure => nil, :no_error => {22 => nil} )
         value
       else
@@ -166,7 +163,7 @@ module OklahomaMixer
     def keys(options = { })
       prefix = options.fetch(:prefix, "").to_s
       limit  = options.fetch(:limit,  -1)
-      list   = ArrayList.new(C.fwmkeys(@db, prefix, prefix.size, limit))
+      list   = ArrayList.new(lib.fwmkeys(@db, prefix, prefix.size, limit))
       list.to_a
     ensure
       list.free if list
@@ -182,8 +179,7 @@ module OklahomaMixer
     
     def delete(key, &missing_handler)
       value = fetch(key, &missing_handler)
-      k     = key.to_s
-      try(:out, k, k.size, :no_error => {22 => nil})
+      try(:out, cast_key_in(key), :no_error => {22 => nil})
       value
     rescue IndexError
       nil
@@ -205,7 +201,7 @@ module OklahomaMixer
     alias_method :member?,  :include?
     
     def size
-      C.rnum(@db)
+      lib.rnum(@db)
     end
     alias_method :length, :size
     
@@ -251,6 +247,15 @@ module OklahomaMixer
       end
     end
     
+    def to_hash(set_default = true)
+      default = @default && lambda { |hash, key| @default[key] } if set_default
+      hash    = Hash.new(&default)
+      each do |key, value|
+        hash[key] ||= value
+      end
+      hash
+    end
+    
     ####################
     ### Transactions ###
     ####################
@@ -296,21 +301,26 @@ module OklahomaMixer
     #######
     private
     #######
+
+    def lib
+      @c ||= self.class.const_get(:C)
+    end
     
     def try(func, *args)
       options  = args.last.is_a?(Hash) ? args.pop : { }
       failure  = options.fetch(:failure, false)
       no_error = options.fetch(:no_error, { })
-      result   = func == :read_from_func                      ?
-                 C.read_from_func(args[0], @db, *args[1..-1]) :
-                 C.send(func, @db, *args)
-      if (failure.is_a?(Proc) and failure[result]) or result == failure
-        error_code = C.ecode(@db)
+      result   = func == :read_from_func                                ?
+                 lib.read_from_func(args[0], @db, *args[1..-1].flatten) :
+                 lib.send(func, @db, *args.flatten)
+      if failure.is_a?(Proc) ? failure[result] : result == failure
+        error_code = lib.ecode(@db)
         if no_error.include? error_code
           no_error[error_code]
         else
-          error_message = C.errmsg(error_code)
-          fail Error::CabinetError, "#{error_message} (#{error_code})"
+          error_message = lib.errmsg(error_code)
+          fail Error::CabinetError,
+               "#{error_message} (error code #{error_code})"
         end
       else
         result
@@ -321,15 +331,35 @@ module OklahomaMixer
       return str_or_int if str_or_int.is_a? Integer
       const = "#{name.to_s.upcase}S"
       names = self.class.const_get(const)
-      enum  = C.const_get(const)
+      enum  = lib.const_get(const)
       str_or_int.to_s.downcase.scan(/./m).inject(0) do |int, c|
         if n = names[c]
-          int | enum[n]
+          int | enum["#{self.class.to_s[/([HBFT])\w+\z/, 1]}DB#{n}".to_sym]
         else
           warn "skipping unrecognized #{name}"
           int
         end
       end
     end
+    
+    def tune(options)
+      if self.class == HashDatabase and
+         options.values_at(:bnum, :apow, :fpow, :opts).any?
+        optimize(options.merge(:tune => true))
+      end
+      {:rcnum => :cache, :xmsiz => nil, :dfunit => nil}.each do |option, func|
+        next if func == :cache and self.class != HashDatabase
+        if i = options[option]
+          try("set#{func || option}", i.to_i)
+        end
+      end
+    end
+    
+    def cast_to_bytes_and_length(object)
+      bytes = object.to_s
+      [bytes, bytes.length]
+    end
+    alias_method :cast_key_in,   :cast_to_bytes_and_length
+    alias_method :cast_value_in, :cast_to_bytes_and_length
   end
 end

data/lib/oklahoma_mixer/hash_database/c.rb

@@ -3,109 +3,26 @@ module OklahomaMixer
     module C  # :nodoc:
       extend OklahomaMixer::Utilities::FFIDSL
 
-      MODES = enum :HDBOREADER,  1 << 0,
-                   :HDBOWRITER,  1 << 1,
-                   :HDBOCREAT,   1 << 2,
-                   :HDBOTRUNC,   1 << 3,
-                   :HDBONOLCK,   1 << 4,
-                   :HDBOLCKNB,   1 << 5,
-                   :HDBOTSYNC,   1 << 6
-      OPTS  = enum :HDBTLARGE,   1 << 0,
-                   :HDBTDEFLATE, 1 << 1,
-                   :HDBTBZIP,    1 << 2,
-                   :HDBTTCBS,    1 << 3
-      
       prefix :tchdb
       
-      def_new_and_del_funcs
-      func :name    => :open,
-           :args    => [:pointer, :string, MODES],
-           :returns => :bool
-      func :name    => :sync,
-           :args    => :pointer,
-           :returns => :bool
-      func :name    => :fsiz,
-           :args    => :pointer,
-           :returns => :uint64
-      func :name    => :copy,
-           :args    => [:pointer, :string],
-           :returns => :bool
-      func :name    => :defrag,
-           :args    => [:pointer, :int64],
-           :returns => :bool
+      def_hash_database_consts_and_funcs
 
-      func :name    => :ecode,
-           :args    => :pointer,
-           :returns => :int
-      func :name    => :errmsg,
-           :args    => :int,
-           :returns => :string
-
-      func :name    => :setmutex,
-           :args    => :pointer,
-           :returns => :bool
       func :name    => :tune,
            :args    => [:pointer, :int64, :int8, :int8, OPTS],
            :returns => :bool
       func :name    => :setcache,
            :args    => [:pointer, :int32],
            :returns => :bool
-      func :name    => :setxmsiz,
-           :args    => [:pointer, :int64],
-           :returns => :bool
-      func :name    => :setdfunit,
-           :args    => [:pointer, :int32],
-           :returns => :bool
       func :name    => :optimize,
            :args    => [:pointer, :int64, :int8, :int8, OPTS],
            :returns => :bool
-
-      func :name    => :put,
-           :args    => [:pointer, :pointer, :int, :pointer, :int],
-           :returns => :bool
-      func :name    => :putkeep,
-           :args    => [:pointer, :pointer, :int, :pointer, :int],
-           :returns => :bool
-      func :name    => :putcat,
-           :args    => [:pointer, :pointer, :int, :pointer, :int],
-           :returns => :bool
+           
       func :name    => :putasync,
            :args    => [:pointer, :pointer, :int, :pointer, :int],
            :returns => :bool
-      call :name    => :TCPDPROC,
-           :args    => [:pointer, :int, :pointer, :pointer],
-           :returns => :pointer
-      func :name    => :putproc,
-           :args    => [:pointer, :pointer, :int, :pointer, :int, :TCPDPROC,
-                        :pointer],
-           :returns => :bool
-      func :name    => :addint,
-           :args    => [:pointer, :pointer, :int, :int],
-           :returns => :int
-      func :name    => :adddouble,
-           :args    => [:pointer, :pointer, :int, :double],
-           :returns => :double
-      func :name    => :out,
-           :args    => [:pointer, :pointer, :int],
-           :returns => :bool
-      func :name    => :get,
-           :args    => [:pointer, :pointer, :int, :pointer],
-           :returns => :pointer
-      func :name    => :vanish,
-           :args    => :pointer,
-           :returns => :bool
-      func :name    => :vanish,
-           :args    => :pointer,
-           :returns => :bool
-      func :name    => :fwmkeys,
-           :args    => [:pointer, :pointer, :int, :int],
-           :returns => :pointer
-      func :name    => :rnum,
-           :args    => :pointer,
-           :returns => :uint64
 
       func :name    => :iterinit,
-           :args    => [:pointer],
+           :args    => :pointer,
            :returns => :bool
       func :name    => :iternext,
            :args    => [:pointer, :pointer],
@@ -113,16 +30,6 @@ module OklahomaMixer
       func :name    => :iternext3,
            :args    => [:pointer, :pointer, :pointer],
            :returns => :bool
-
-      func :name    => :tranbegin,
-           :args    => :pointer,
-           :returns => :bool
-      func :name    => :trancommit,
-           :args    => :pointer,
-           :returns => :bool
-      func :name    => :tranabort,
-           :args    => :pointer,
-           :returns => :bool
     end
   end
 end

data/lib/oklahoma_mixer/utilities.rb

@@ -22,6 +22,12 @@ module OklahomaMixer
         defined?(@prefix) and @prefix
       end
       
+      def const(name, values)
+        const_set( name, enum( *(0...values.size).map { |i|
+          ["#{prefix.to_s[2..-1].upcase}#{values[i]}".to_sym, 1 << i]
+        }.flatten ) )
+      end
+      
       def func(details)
         args =  [ ]
         args << details.fetch(:alias, details[:name])
@@ -57,12 +63,108 @@ module OklahomaMixer
         func :name    => :del,
              :args    => :pointer
       end
+      
+      def def_core_database_consts_and_funcs
+        const :MODES, %w[OREADER OWRITER OCREAT OTRUNC ONOLCK OLCKNB OTSYNC]
+
+        def_new_and_del_funcs
+        
+        func :name    => :open,
+             :args    => [:pointer, :string, const_get(:MODES)],
+             :returns => :bool
+        func :name    => :sync,
+             :args    => :pointer,
+             :returns => :bool
+        func :name    => :fsiz,
+             :args    => :pointer,
+             :returns => :uint64
+        func :name    => :copy,
+             :args    => [:pointer, :string],
+             :returns => :bool
+
+        func :name    => :ecode,
+             :args    => :pointer,
+             :returns => :int
+        func :name    => :errmsg,
+             :args    => :int,
+             :returns => :string
+
+        func :name    => :setmutex,
+             :args    => :pointer,
+             :returns => :bool
+
+        func :name    => :vanish,
+             :args    => :pointer,
+             :returns => :bool
+        func :name    => :rnum,
+             :args    => :pointer,
+             :returns => :uint64
+
+        func :name    => :tranbegin,
+             :args    => :pointer,
+             :returns => :bool
+        func :name    => :trancommit,
+             :args    => :pointer,
+             :returns => :bool
+        func :name    => :tranabort,
+             :args    => :pointer,
+             :returns => :bool
+      end
+      
+      def def_hash_database_consts_and_funcs
+        const :OPTS, %w[TLARGE TDEFLATE TBZIP TTCBS]
+
+        def_core_database_consts_and_funcs
+
+        func :name    => :defrag,
+             :args    => [:pointer, :int64],
+             :returns => :bool
+
+        func :name    => :setxmsiz,
+             :args    => [:pointer, :int64],
+             :returns => :bool
+        func :name    => :setdfunit,
+             :args    => [:pointer, :int32],
+             :returns => :bool
+
+        func :name    => :put,
+             :args    => [:pointer, :pointer, :int, :pointer, :int],
+             :returns => :bool
+        func :name    => :putkeep,
+             :args    => [:pointer, :pointer, :int, :pointer, :int],
+             :returns => :bool
+        func :name    => :putcat,
+             :args    => [:pointer, :pointer, :int, :pointer, :int],
+             :returns => :bool
+        call :name    => :TCPDPROC,
+             :args    => [:pointer, :int, :pointer, :pointer],
+             :returns => :pointer
+        func :name    => :putproc,
+             :args    => [:pointer, :pointer, :int, :pointer, :int, :TCPDPROC,
+                          :pointer],
+             :returns => :bool
+        func :name    => :addint,
+             :args    => [:pointer, :pointer, :int, :int],
+             :returns => :int
+        func :name    => :adddouble,
+             :args    => [:pointer, :pointer, :int, :double],
+             :returns => :double
+        func :name    => :out,
+             :args    => [:pointer, :pointer, :int],
+             :returns => :bool
+        func :name    => :get,
+             :args    => [:pointer, :pointer, :int, :pointer],
+             :returns => :pointer
+        func :name    => :fwmkeys,
+             :args    => [:pointer, :pointer, :int, :int],
+             :returns => :pointer
+      end
     end
     
-    int_min = `getconf INT_MIN 2>&1`[/-\d+/]
-    unless INT_MIN = int_min && int_min.to_i
-      warn "set OKMixer::Utilities::INT_MIN before using counters"
+    unless int_min = `getconf INT_MIN 2>&1`[/-\d+/]
+      warn "set OKMixer::Utilities::INT_MIN before using the :add storage mode"
     end
+    INT_MIN = int_min && int_min.to_i
     
     def self.temp_int
       int = FFI::MemoryPointer.new(:int)
@@ -82,7 +184,10 @@ module OklahomaMixer
     
     prefix :tc
     
-    func :name => :free,
-         :args => :pointer
+    func :name    => :malloc,
+         :args    => :size_t,
+         :returns => :pointer
+    func :name    => :free,
+         :args    => :pointer
   end
 end