hyperdex 1.4.5.1.gc197953

data/ext/depend

@@ -0,0 +1 @@
+client.o: definitions.c prototypes.c

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+require "mkmf"
+
+$defs.push "-DHYPERDEX_CLIENT"
+
+dir_config('hyperdex')
+$libs = append_library($libs, 'hyperdex-client')
+
+$srcs = %w{client.c hyperdex.c}
+
+create_makefile('_hyperdex')

data/ext/hyperdex.c

@@ -0,0 +1,42 @@
+/* Copyright (c) 2013, Cornell University
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of HyperDex nor the names of its contributors may be
+ *       used to endorse or promote products derived from this software without
+ *       specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* Ruby */
+#include <ruby/ruby.h>
+
+VALUE mod_hyperdex;
+
+void Init_hyperdex_client(void);
+
+void
+Init__hyperdex()
+{
+    mod_hyperdex = rb_define_module("HyperDex");
+
+    Init_hyperdex_client();
+};

data/ext/prototypes.c

@@ -0,0 +1,163 @@
+/* Copyright (c) 2013-2014, Cornell University
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimer in the
+ *       documentation and/or other materials provided with the distribution.
+ *     * Neither the name of HyperDex nor the names of its contributors may be
+ *       used to endorse or promote products derived from this software without
+ *       specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/* This file is generated by bindings/ruby.py */
+
+rb_define_method(class_client, "async_get", hyperdex_ruby_client_get, 2);
+rb_define_method(class_client, "get", hyperdex_ruby_client_wait_get, 2);
+rb_define_method(class_client, "async_get_partial", hyperdex_ruby_client_get_partial, 3);
+rb_define_method(class_client, "get_partial", hyperdex_ruby_client_wait_get_partial, 3);
+rb_define_method(class_client, "async_put", hyperdex_ruby_client_put, 3);
+rb_define_method(class_client, "put", hyperdex_ruby_client_wait_put, 3);
+rb_define_method(class_client, "async_cond_put", hyperdex_ruby_client_cond_put, 4);
+rb_define_method(class_client, "cond_put", hyperdex_ruby_client_wait_cond_put, 4);
+rb_define_method(class_client, "async_put_if_not_exist", hyperdex_ruby_client_put_if_not_exist, 3);
+rb_define_method(class_client, "put_if_not_exist", hyperdex_ruby_client_wait_put_if_not_exist, 3);
+rb_define_method(class_client, "async_del", hyperdex_ruby_client_del, 2);
+rb_define_method(class_client, "del", hyperdex_ruby_client_wait_del, 2);
+rb_define_method(class_client, "async_cond_del", hyperdex_ruby_client_cond_del, 3);
+rb_define_method(class_client, "cond_del", hyperdex_ruby_client_wait_cond_del, 3);
+rb_define_method(class_client, "async_atomic_add", hyperdex_ruby_client_atomic_add, 3);
+rb_define_method(class_client, "atomic_add", hyperdex_ruby_client_wait_atomic_add, 3);
+rb_define_method(class_client, "async_cond_atomic_add", hyperdex_ruby_client_cond_atomic_add, 4);
+rb_define_method(class_client, "cond_atomic_add", hyperdex_ruby_client_wait_cond_atomic_add, 4);
+rb_define_method(class_client, "async_atomic_sub", hyperdex_ruby_client_atomic_sub, 3);
+rb_define_method(class_client, "atomic_sub", hyperdex_ruby_client_wait_atomic_sub, 3);
+rb_define_method(class_client, "async_cond_atomic_sub", hyperdex_ruby_client_cond_atomic_sub, 4);
+rb_define_method(class_client, "cond_atomic_sub", hyperdex_ruby_client_wait_cond_atomic_sub, 4);
+rb_define_method(class_client, "async_atomic_mul", hyperdex_ruby_client_atomic_mul, 3);
+rb_define_method(class_client, "atomic_mul", hyperdex_ruby_client_wait_atomic_mul, 3);
+rb_define_method(class_client, "async_cond_atomic_mul", hyperdex_ruby_client_cond_atomic_mul, 4);
+rb_define_method(class_client, "cond_atomic_mul", hyperdex_ruby_client_wait_cond_atomic_mul, 4);
+rb_define_method(class_client, "async_atomic_div", hyperdex_ruby_client_atomic_div, 3);
+rb_define_method(class_client, "atomic_div", hyperdex_ruby_client_wait_atomic_div, 3);
+rb_define_method(class_client, "async_cond_atomic_div", hyperdex_ruby_client_cond_atomic_div, 4);
+rb_define_method(class_client, "cond_atomic_div", hyperdex_ruby_client_wait_cond_atomic_div, 4);
+rb_define_method(class_client, "async_atomic_mod", hyperdex_ruby_client_atomic_mod, 3);
+rb_define_method(class_client, "atomic_mod", hyperdex_ruby_client_wait_atomic_mod, 3);
+rb_define_method(class_client, "async_cond_atomic_mod", hyperdex_ruby_client_cond_atomic_mod, 4);
+rb_define_method(class_client, "cond_atomic_mod", hyperdex_ruby_client_wait_cond_atomic_mod, 4);
+rb_define_method(class_client, "async_atomic_and", hyperdex_ruby_client_atomic_and, 3);
+rb_define_method(class_client, "atomic_and", hyperdex_ruby_client_wait_atomic_and, 3);
+rb_define_method(class_client, "async_cond_atomic_and", hyperdex_ruby_client_cond_atomic_and, 4);
+rb_define_method(class_client, "cond_atomic_and", hyperdex_ruby_client_wait_cond_atomic_and, 4);
+rb_define_method(class_client, "async_atomic_or", hyperdex_ruby_client_atomic_or, 3);
+rb_define_method(class_client, "atomic_or", hyperdex_ruby_client_wait_atomic_or, 3);
+rb_define_method(class_client, "async_cond_atomic_or", hyperdex_ruby_client_cond_atomic_or, 4);
+rb_define_method(class_client, "cond_atomic_or", hyperdex_ruby_client_wait_cond_atomic_or, 4);
+rb_define_method(class_client, "async_atomic_xor", hyperdex_ruby_client_atomic_xor, 3);
+rb_define_method(class_client, "atomic_xor", hyperdex_ruby_client_wait_atomic_xor, 3);
+rb_define_method(class_client, "async_cond_atomic_xor", hyperdex_ruby_client_cond_atomic_xor, 4);
+rb_define_method(class_client, "cond_atomic_xor", hyperdex_ruby_client_wait_cond_atomic_xor, 4);
+rb_define_method(class_client, "async_string_prepend", hyperdex_ruby_client_string_prepend, 3);
+rb_define_method(class_client, "string_prepend", hyperdex_ruby_client_wait_string_prepend, 3);
+rb_define_method(class_client, "async_cond_string_prepend", hyperdex_ruby_client_cond_string_prepend, 4);
+rb_define_method(class_client, "cond_string_prepend", hyperdex_ruby_client_wait_cond_string_prepend, 4);
+rb_define_method(class_client, "async_string_append", hyperdex_ruby_client_string_append, 3);
+rb_define_method(class_client, "string_append", hyperdex_ruby_client_wait_string_append, 3);
+rb_define_method(class_client, "async_cond_string_append", hyperdex_ruby_client_cond_string_append, 4);
+rb_define_method(class_client, "cond_string_append", hyperdex_ruby_client_wait_cond_string_append, 4);
+rb_define_method(class_client, "async_list_lpush", hyperdex_ruby_client_list_lpush, 3);
+rb_define_method(class_client, "list_lpush", hyperdex_ruby_client_wait_list_lpush, 3);
+rb_define_method(class_client, "async_cond_list_lpush", hyperdex_ruby_client_cond_list_lpush, 4);
+rb_define_method(class_client, "cond_list_lpush", hyperdex_ruby_client_wait_cond_list_lpush, 4);
+rb_define_method(class_client, "async_list_rpush", hyperdex_ruby_client_list_rpush, 3);
+rb_define_method(class_client, "list_rpush", hyperdex_ruby_client_wait_list_rpush, 3);
+rb_define_method(class_client, "async_cond_list_rpush", hyperdex_ruby_client_cond_list_rpush, 4);
+rb_define_method(class_client, "cond_list_rpush", hyperdex_ruby_client_wait_cond_list_rpush, 4);
+rb_define_method(class_client, "async_set_add", hyperdex_ruby_client_set_add, 3);
+rb_define_method(class_client, "set_add", hyperdex_ruby_client_wait_set_add, 3);
+rb_define_method(class_client, "async_cond_set_add", hyperdex_ruby_client_cond_set_add, 4);
+rb_define_method(class_client, "cond_set_add", hyperdex_ruby_client_wait_cond_set_add, 4);
+rb_define_method(class_client, "async_set_remove", hyperdex_ruby_client_set_remove, 3);
+rb_define_method(class_client, "set_remove", hyperdex_ruby_client_wait_set_remove, 3);
+rb_define_method(class_client, "async_cond_set_remove", hyperdex_ruby_client_cond_set_remove, 4);
+rb_define_method(class_client, "cond_set_remove", hyperdex_ruby_client_wait_cond_set_remove, 4);
+rb_define_method(class_client, "async_set_intersect", hyperdex_ruby_client_set_intersect, 3);
+rb_define_method(class_client, "set_intersect", hyperdex_ruby_client_wait_set_intersect, 3);
+rb_define_method(class_client, "async_cond_set_intersect", hyperdex_ruby_client_cond_set_intersect, 4);
+rb_define_method(class_client, "cond_set_intersect", hyperdex_ruby_client_wait_cond_set_intersect, 4);
+rb_define_method(class_client, "async_set_union", hyperdex_ruby_client_set_union, 3);
+rb_define_method(class_client, "set_union", hyperdex_ruby_client_wait_set_union, 3);
+rb_define_method(class_client, "async_cond_set_union", hyperdex_ruby_client_cond_set_union, 4);
+rb_define_method(class_client, "cond_set_union", hyperdex_ruby_client_wait_cond_set_union, 4);
+rb_define_method(class_client, "async_map_add", hyperdex_ruby_client_map_add, 3);
+rb_define_method(class_client, "map_add", hyperdex_ruby_client_wait_map_add, 3);
+rb_define_method(class_client, "async_cond_map_add", hyperdex_ruby_client_cond_map_add, 4);
+rb_define_method(class_client, "cond_map_add", hyperdex_ruby_client_wait_cond_map_add, 4);
+rb_define_method(class_client, "async_map_remove", hyperdex_ruby_client_map_remove, 3);
+rb_define_method(class_client, "map_remove", hyperdex_ruby_client_wait_map_remove, 3);
+rb_define_method(class_client, "async_cond_map_remove", hyperdex_ruby_client_cond_map_remove, 4);
+rb_define_method(class_client, "cond_map_remove", hyperdex_ruby_client_wait_cond_map_remove, 4);
+rb_define_method(class_client, "async_map_atomic_add", hyperdex_ruby_client_map_atomic_add, 3);
+rb_define_method(class_client, "map_atomic_add", hyperdex_ruby_client_wait_map_atomic_add, 3);
+rb_define_method(class_client, "async_cond_map_atomic_add", hyperdex_ruby_client_cond_map_atomic_add, 4);
+rb_define_method(class_client, "cond_map_atomic_add", hyperdex_ruby_client_wait_cond_map_atomic_add, 4);
+rb_define_method(class_client, "async_map_atomic_sub", hyperdex_ruby_client_map_atomic_sub, 3);
+rb_define_method(class_client, "map_atomic_sub", hyperdex_ruby_client_wait_map_atomic_sub, 3);
+rb_define_method(class_client, "async_cond_map_atomic_sub", hyperdex_ruby_client_cond_map_atomic_sub, 4);
+rb_define_method(class_client, "cond_map_atomic_sub", hyperdex_ruby_client_wait_cond_map_atomic_sub, 4);
+rb_define_method(class_client, "async_map_atomic_mul", hyperdex_ruby_client_map_atomic_mul, 3);
+rb_define_method(class_client, "map_atomic_mul", hyperdex_ruby_client_wait_map_atomic_mul, 3);
+rb_define_method(class_client, "async_cond_map_atomic_mul", hyperdex_ruby_client_cond_map_atomic_mul, 4);
+rb_define_method(class_client, "cond_map_atomic_mul", hyperdex_ruby_client_wait_cond_map_atomic_mul, 4);
+rb_define_method(class_client, "async_map_atomic_div", hyperdex_ruby_client_map_atomic_div, 3);
+rb_define_method(class_client, "map_atomic_div", hyperdex_ruby_client_wait_map_atomic_div, 3);
+rb_define_method(class_client, "async_cond_map_atomic_div", hyperdex_ruby_client_cond_map_atomic_div, 4);
+rb_define_method(class_client, "cond_map_atomic_div", hyperdex_ruby_client_wait_cond_map_atomic_div, 4);
+rb_define_method(class_client, "async_map_atomic_mod", hyperdex_ruby_client_map_atomic_mod, 3);
+rb_define_method(class_client, "map_atomic_mod", hyperdex_ruby_client_wait_map_atomic_mod, 3);
+rb_define_method(class_client, "async_cond_map_atomic_mod", hyperdex_ruby_client_cond_map_atomic_mod, 4);
+rb_define_method(class_client, "cond_map_atomic_mod", hyperdex_ruby_client_wait_cond_map_atomic_mod, 4);
+rb_define_method(class_client, "async_map_atomic_and", hyperdex_ruby_client_map_atomic_and, 3);
+rb_define_method(class_client, "map_atomic_and", hyperdex_ruby_client_wait_map_atomic_and, 3);
+rb_define_method(class_client, "async_cond_map_atomic_and", hyperdex_ruby_client_cond_map_atomic_and, 4);
+rb_define_method(class_client, "cond_map_atomic_and", hyperdex_ruby_client_wait_cond_map_atomic_and, 4);
+rb_define_method(class_client, "async_map_atomic_or", hyperdex_ruby_client_map_atomic_or, 3);
+rb_define_method(class_client, "map_atomic_or", hyperdex_ruby_client_wait_map_atomic_or, 3);
+rb_define_method(class_client, "async_cond_map_atomic_or", hyperdex_ruby_client_cond_map_atomic_or, 4);
+rb_define_method(class_client, "cond_map_atomic_or", hyperdex_ruby_client_wait_cond_map_atomic_or, 4);
+rb_define_method(class_client, "async_map_atomic_xor", hyperdex_ruby_client_map_atomic_xor, 3);
+rb_define_method(class_client, "map_atomic_xor", hyperdex_ruby_client_wait_map_atomic_xor, 3);
+rb_define_method(class_client, "async_cond_map_atomic_xor", hyperdex_ruby_client_cond_map_atomic_xor, 4);
+rb_define_method(class_client, "cond_map_atomic_xor", hyperdex_ruby_client_wait_cond_map_atomic_xor, 4);
+rb_define_method(class_client, "async_map_string_prepend", hyperdex_ruby_client_map_string_prepend, 3);
+rb_define_method(class_client, "map_string_prepend", hyperdex_ruby_client_wait_map_string_prepend, 3);
+rb_define_method(class_client, "async_cond_map_string_prepend", hyperdex_ruby_client_cond_map_string_prepend, 4);
+rb_define_method(class_client, "cond_map_string_prepend", hyperdex_ruby_client_wait_cond_map_string_prepend, 4);
+rb_define_method(class_client, "async_map_string_append", hyperdex_ruby_client_map_string_append, 3);
+rb_define_method(class_client, "map_string_append", hyperdex_ruby_client_wait_map_string_append, 3);
+rb_define_method(class_client, "async_cond_map_string_append", hyperdex_ruby_client_cond_map_string_append, 4);
+rb_define_method(class_client, "cond_map_string_append", hyperdex_ruby_client_wait_cond_map_string_append, 4);
+rb_define_method(class_client, "search", hyperdex_ruby_client_search, 2);
+rb_define_method(class_client, "async_search_describe", hyperdex_ruby_client_search_describe, 2);
+rb_define_method(class_client, "search_describe", hyperdex_ruby_client_wait_search_describe, 2);
+rb_define_method(class_client, "sorted_search", hyperdex_ruby_client_sorted_search, 5);
+rb_define_method(class_client, "async_group_del", hyperdex_ruby_client_group_del, 2);
+rb_define_method(class_client, "group_del", hyperdex_ruby_client_wait_group_del, 2);
+rb_define_method(class_client, "async_count", hyperdex_ruby_client_count, 2);
+rb_define_method(class_client, "count", hyperdex_ruby_client_wait_count, 2);

data/lib/ffi/monkey_patches.rb

@@ -0,0 +1,10 @@
+module FFI
+	class Pointer
+		type = FFI.find_type(:size_t)
+		type, _ = FFI::TypeDefs.find do |(name, t)|
+			method_defined? "read_#{name}" if t == type
+		end
+
+		alias_method :read_size_t, "read_#{type}" if type
+	end
+end

data/lib/hyperdex.rb

@@ -0,0 +1,25 @@
+require '_hyperdex'
+
+module HyperDex; end
+
+require_relative 'hyperdex/ffi'
+
+require 'ffi'
+
+module HyperDex
+	def self.init_ds_iterator(type, value)
+		::FFI::MemoryPointer.new(HyperDex::FFI::DS::DsIterator, 1).tap do |iter|
+			HyperDex::FFI::DS.iterator_init(iter,
+			  type,
+			  ::FFI::MemoryPointer.from_string(value),
+			  value.length
+			)
+		end
+	end
+
+	DataType = Module.new
+	HyperDex::FFI::DS.enum_type(:hyperdatatype).set_consts(DataType)
+end
+
+require_relative 'hyperdex/admin'
+require_relative 'hyperdex/client'

data/lib/hyperdex/admin.rb

@@ -0,0 +1,4 @@
+module HyperDex::Admin; end
+
+require_relative 'admin/client'
+require_relative 'admin/exception'

data/lib/hyperdex/admin/client.rb

@@ -0,0 +1,71 @@
+class HyperDex::Admin::Client
+	attr_reader :host, :port
+
+	def initialize(host = 'localhost', port = 1982)
+		@host = host
+		@port = port
+		@client = ::FFI::AutoPointer.new(
+		              HyperDex::FFI::Admin.create(
+		                ::FFI::MemoryPointer.from_string(host),
+		                port
+		              ),
+		              proc { |p| HyperDex::FFI::Admin.destroy(p) }
+		            )
+	end
+
+	def list_spaces
+		ptr = ::FFI::MemoryPointer.new(:pointer)
+
+		make_request(:list_spaces, :rc, ptr)
+
+		ptr.read_pointer.read_string.split("\n").map { |s| s.to_sym }
+	end
+
+	def add_space(definition)
+		make_request(
+		  :add_space,
+		  ::FFI::MemoryPointer.from_string(definition.to_s),
+		  :rc
+		)
+	end
+
+	def rm_space(name)
+		make_request(
+		  :rm_space,
+		  ::FFI::MemoryPointer.from_string(name.to_s),
+		  :rc
+		)
+	end
+
+	private
+	def make_request(f, *args)
+		rc = ::FFI::MemoryPointer.new(:int)
+
+		# Sigh... not all functions have the returncode as the last arg, so we
+		# need to specify where the rc parameter is in the arg list with this
+		# special symbol.
+		args.map! { |e| (:rc == e) ? rc : e }
+		reqid = HyperDex::FFI::Admin.__send__(f, @client, *args)
+
+		if reqid < 0
+			raise HyperDex::Admin::Exception.new(rc.read_int, "hyperdex_admin_#{f} failed")
+		end
+
+		wait_for_response(reqid)
+	end
+
+	def wait_for_response(reqid)
+		rc = ::FFI::MemoryPointer.new(:int)
+
+		if (ri = HyperDex::FFI::Admin.loop(@client, -1, rc)) != reqid
+			raise HyperDex::Admin::Exception.new(
+			        HyperDex::Admin::EXCEPTION,
+			        "CAN'T HAPPEN: hyperdex_admin_loop() returned an unknown reqid (expected #{reqid}, got #{ri})"
+			      )
+		end
+
+		if ri < 0
+			raise HyperDex::Admin::Exception.new(rc.read_int, "hyperdex_admin_loop failed")
+		end
+	end
+end

data/lib/hyperdex/admin/exception.rb

@@ -0,0 +1,11 @@
+class HyperDex::Admin::Exception < StandardError
+	attr_reader :status, :detail
+
+	def initialize(rc, detail)
+		@status = rc
+		@detail = detail
+
+		rc_string = HyperDex::FFI::Admin.returncode_to_string(rc).read_string
+		super("#{rc_string} (#{rc}): #{detail}")
+	end
+end

data/lib/hyperdex/client.rb

@@ -0,0 +1,377 @@
+require 'ffi'
+require 'ffi/monkey_patches'
+require 'ffi/tools/const_generator'
+
+module HyperDex::Client
+	def self.encode_attributes(attrs, attrs_size)
+		(0..attrs_size-1).inject({}) do |h, i|
+			attr = Attribute.new(attrs[i*Attribute.size])
+			k = attr[:name].read_string.to_sym
+			h.tap { |h|	h[k] = build_attribute(attr) }
+		end
+	end
+
+	def self.build_attribute(attr)
+		type = attr[:datatype]
+		value = attr[:value].read_string(attr[:value_sz])
+
+		case type
+		when :STRING
+			value
+
+		when :INT64
+			i = ::FFI::MemoryPointer.new(:int64_t)
+			if HyperDex::FFI::DS.unpack_int(attr[:value], attr[:value_sz], i) < 0
+				raise HyperDex::Client::HyperDexClientException.new(
+				        HyperDex::Client::SERVERERROR,
+				        "server sent malformed int attribute (#{value.inspect})"
+				      )
+			end
+
+			i.read_int64
+
+		when :FLOAT
+			d = ::FFI::MemoryPointer.new(:double)
+			if HyperDex::FFI::DS.unpack_float(attr[:value], attr[:value_sz], d) < 0
+				raise HyperDex::Client::HyperDexClientException.new(
+				        HyperDex::Client::SERVERERROR,
+				        "server sent malformed float attribute (#{value.inspect})"
+				      )
+			end
+
+			d.read_double
+
+		when :DOCUMENT
+			begin
+				JSON.parse(value)
+			rescue JSON::ParserError
+				raise HyperDex::Client::HyperDexClientException.new(
+				        HyperDex::Client::SERVERERROR,
+				        "server sent malformed attribute(document)"
+				      )
+			end
+
+		when :LIST_STRING
+			iter = HyperDex.init_ds_iterator(type, value)
+			ptr = ::FFI::MemoryPointer.new(:pointer)
+			len = ::FFI::MemoryPointer.new(:size_t)
+
+			res = []
+			while (result = HyperDex::FFI::DS.iterate_list_string_next(iter, ptr, len)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed list(string)"
+					      )
+				end
+
+				str = ptr.read_pointer
+				res << (str.null? ? nil : str.read_string(len.read_size_t))
+			end
+
+			res
+
+		when :LIST_INT64
+			iter = HyperDex.init_ds_iterator(type, value)
+			int = ::FFI::MemoryPointer.new(:int64_t)
+
+			res = []
+			while (result = HyperDex::FFI::DS.iterate_list_int_next(iter, int)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed list(int)"
+					      )
+				end
+
+				res << int.read_int64
+			end
+
+			res
+
+		when :LIST_FLOAT
+			iter = HyperDex.init_ds_iterator(type, value)
+			dbl = ::FFI::MemoryPointer.new(:double)
+
+			res = []
+			while (result = HyperDex::FFI::DS.iterate_list_float_next(iter, dbl)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed list(float)"
+					      )
+				end
+
+				res << dbl.read_double
+			end
+
+			res
+
+		when :SET_STRING
+			iter = HyperDex.init_ds_iterator(type, value)
+			ptr = ::FFI::MemoryPointer.new(:pointer)
+			len = ::FFI::MemoryPointer.new(:size_t)
+
+			res = Set.new
+			while (result = HyperDex::FFI::DS.iterate_set_string_next(iter, ptr, len)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed set(string)"
+					      )
+				end
+
+				str = ptr.read_pointer
+				res << (str.null? ? nil : str.read_string(len.read_size_t))
+			end
+
+			res
+
+		when :SET_INT64
+			iter = HyperDex.init_ds_iterator(type, value)
+			int = ::FFI::MemoryPointer.new(:int64_t)
+
+			res = Set.new
+			while (result = HyperDex::FFI::DS.iterate_set_int_next(iter, int)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed set(int)"
+					      )
+				end
+
+				res << int.read_int64
+			end
+
+			res
+
+		when :SET_FLOAT
+			iter = HyperDex.init_ds_iterator(type, value)
+			dbl = ::FFI::MemoryPointer.new(:double)
+
+			res = Set.new
+			while (result = HyperDex::FFI::DS.iterate_set_float_next(iter, dbl)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed set(float)"
+					      )
+				end
+
+				res << dbl.read_double
+			end
+
+			res
+
+		when :MAP_STRING_STRING
+			iter = HyperDex.init_ds_iterator(type, value)
+			kptr = ::FFI::MemoryPointer.new(:pointer)
+			klen = ::FFI::MemoryPointer.new(:size_t)
+			vptr = ::FFI::MemoryPointer.new(:pointer)
+			vlen = ::FFI::MemoryPointer.new(:size_t)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_string_string_next(iter, kptr, klen, vptr, vlen)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(string, string)"
+					      )
+				end
+
+				kstr = kptr.read_pointer
+				kstr = (kstr.null? ? nil : kstr.read_string(klen.read_size_t))
+				vstr = vptr.read_pointer
+				vstr = (vstr.null? ? nil : vstr.read_string(vlen.read_size_t))
+				res[kstr] = vstr
+			end
+
+			res
+
+		when :MAP_STRING_INT64
+			iter = HyperDex.init_ds_iterator(type, value)
+			kptr = ::FFI::MemoryPointer.new(:pointer)
+			klen = ::FFI::MemoryPointer.new(:size_t)
+			vint = ::FFI::MemoryPointer.new(:int64_t)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_string_int_next(iter, kptr, klen, vint)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(string, int)"
+					      )
+				end
+
+				kstr = kptr.read_pointer
+				kstr = (kstr.null? ? nil : kstr.read_string(klen.read_size_t))
+				res[kstr] = vint.read_int64
+			end
+
+			res
+
+		when :MAP_STRING_FLOAT
+			iter = HyperDex.init_ds_iterator(type, value)
+			kptr = ::FFI::MemoryPointer.new(:pointer)
+			klen = ::FFI::MemoryPointer.new(:size_t)
+			vdbl = ::FFI::MemoryPointer.new(:double)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_string_float_next(iter, kptr, klen, vdbl)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(string, float)"
+					      )
+				end
+
+				kstr = kptr.read_pointer
+				kstr = (kstr.null? ? nil : kstr.read_string(klen.read_size_t))
+				res[kstr] = vdbl.read_double
+			end
+
+			res
+
+		when :MAP_INT64_STRING
+			iter = HyperDex.init_ds_iterator(type, value)
+			kint = ::FFI::MemoryPointer.new(:int64_t)
+			vptr = ::FFI::MemoryPointer.new(:pointer)
+			vlen = ::FFI::MemoryPointer.new(:size_t)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_int_string_next(iter, kint, vptr, vlen)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(int, string)"
+					      )
+				end
+
+				vstr = vptr.read_pointer
+				vstr = (vstr.null? ? nil : vstr.read_string(vlen.read_size_t))
+				res[kint.read_int64] = vstr
+			end
+
+			res
+
+		when :MAP_INT64_INT64
+			iter = HyperDex.init_ds_iterator(type, value)
+			kint = ::FFI::MemoryPointer.new(:int64_t)
+			vint = ::FFI::MemoryPointer.new(:int64_t)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_int_int_next(iter, kint, vint)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(int, int)"
+					      )
+				end
+
+				res[kint.read_int64] = vint.read_int64
+			end
+
+			res
+
+		when :MAP_INT64_FLOAT
+			iter = HyperDex.init_ds_iterator(type, value)
+			kint = ::FFI::MemoryPointer.new(:int64_t)
+			vdbl = ::FFI::MemoryPointer.new(:double)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_int_float_next(iter, kint, vdbl)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(int, float)"
+					      )
+				end
+
+				res[kint.read_int64] = vdbl.read_double
+			end
+
+			res
+
+		when :MAP_FLOAT_STRING
+			iter = HyperDex.init_ds_iterator(type, value)
+			kdbl = ::FFI::MemoryPointer.new(:double)
+			vptr = ::FFI::MemoryPointer.new(:pointer)
+			vlen = ::FFI::MemoryPointer.new(:size_t)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_float_string_next(iter, kdbl, vptr, vlen)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(float, string)"
+					      )
+				end
+
+				vstr = vptr.read_pointer
+				vstr = (vstr.null? ? nil : vstr.read_string(vlen.read_size_t))
+				res[kdbl.read_double] = vstr
+			end
+
+			res
+
+		when :MAP_FLOAT_INT64
+			iter = HyperDex.init_ds_iterator(type, value)
+			kdbl = ::FFI::MemoryPointer.new(:double)
+			vint = ::FFI::MemoryPointer.new(:int64_t)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_float_int_next(iter, kdbl, vint)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(float, int)"
+					      )
+				end
+
+				res[kdbl.read_double] = vint.read_int64
+			end
+
+			res
+
+		when :MAP_FLOAT_FLOAT
+			iter = HyperDex.init_ds_iterator(type, value)
+			kdbl = ::FFI::MemoryPointer.new(:double)
+			vdbl = ::FFI::MemoryPointer.new(:double)
+
+			res = {}
+			while (result = HyperDex::FFI::DS.iterate_map_float_float_next(iter, kdbl, vdbl)) > 0
+				if result < 0
+					raise HyperDex::Client::HyperDexClientException.new(
+					        HyperDex::Client::SERVERERROR,
+					        "server sent malformed map(int, float)"
+					      )
+				end
+
+				res[kdbl.read_double] = vdbl.read_double
+			end
+
+			res
+
+		else
+			raise HyperDex::Client::HyperDexClientException.new(
+			        HyperDex::Client::SERVERERROR,
+			        "server sent malformed attributes"
+			      )
+		end
+	end
+
+	HyperDex::FFI::Client.enum_type(:hyperdex_client_returncode).set_consts(self)
+
+	class Attribute < ::FFI::Struct
+		layout :name,     :pointer,
+		       :value,    :pointer,
+		       :value_sz, :size_t,
+		       :datatype, HyperDex::FFI::DS.enum_type(:hyperdatatype)
+	end
+end
+
+require_relative 'client/client'
+require_relative 'client/deferred'
+require_relative 'client/hyperdex_client_exception'
+require_relative 'client/iterator'
+require_relative 'client/response'