hakuban 0.6.5 → 0.7.0

data/lib/hakuban/ffi.rb

@@ -1,174 +1,250 @@
 require 'json'
 require 'ffi'
+require 'hakuban/ffi-object'
 
 
-# all functions which can trigger synchronuous callbacks, and those which wait on rust locks are "blocking: true" to avoid deadlock on GIL
 module Hakuban::FFI
 
-	class FFILocalNodeNewResult < FFI::Struct
-		layout :error, :uint8, :local_node_pointer, :pointer
-	end
-	
-	class FFIObjectObserveResult < FFI::Struct
-		layout :error, :uint8, :object_observe_pointer, :pointer
-	end
-	
-	class FFIObjectExposeResult < FFI::Struct
-		layout :error, :uint8, :object_expose_pointer, :pointer
-	end
-	
-	class FFITagObserveResult < FFI::Struct
-		layout :error, :uint8, :tag_observe_pointer, :pointer
-	end
-	
-	class FFITagExposeResult < FFI::Struct
-		layout :error, :uint8, :tag_expose_pointer, :pointer
-	end
-	
-	class FFIObjectObserveStateGetVersionResult < FFI::Struct
-		layout :version_length, :size_t, :version_elements, :pointer
-	end
+	extend FFI::Library
+	ffi_lib 'hakuban'
+
+
+	class FFIError < Exception; end
+	class FFIErrorInvalidString < FFIError; end
+	class FFIErrorInvalidJSON < FFIError; end
+	class FFIErrorInvalidURL < FFIError; end
+	class FFIErrorInvalidLogLevel < FFIError; end
+	class FFIErrorUnknownError < FFIError; end
 
-	class FFIObjectObserveStateGetDataTypeResult < FFI::Struct
-		layout :type_length, :size_t, :type_elements, :pointer
+	class FFIResultStatus < FFI::Struct
+		layout :id, :uint8
+		ENUM = [:Ok, :Pending, :NotAvailable, :InvalidString, :InvalidJSON, :InvalidURL, :InvalidLogLevel, :UnknownError]
+
+		def to_sym
+			ENUM[self[:id]]
+		end
+
+		def to_exception
+			Hakuban::FFI::const_get("FFIError"+ENUM[self[:id]].to_s)
+		end
 	end
 
-	class FFIObjectObserveStateGetDataResult < FFI::Struct
-		layout :data_length, :size_t, :data_bytes, :pointer
+
+	class FFIResult < FFI::Struct
+		FFIResultStatus::ENUM.each { |sym|
+			define_method(("is_"+sym.to_s+"?").to_sym) {
+				FFIResultStatus::ENUM[self[:status][:id]] == sym
+			}
+		}
 	end
 
-	class FFIObjectExposeState < FFI::Struct
-		layout :version_length, :size_t, :version, :pointer, :data_type_length, :size_t, :data_type, :pointer, :raw_length, :size_t, :raw, :pointer
-		attr_accessor :data_type_strings
-	
-		def self.construct(version, data_type, data)
-			state = FFIObjectExposeState::new
-			state[:version_length] = version.size
-			state[:version] = FFI::MemoryPointer.new(:int64, version.size)
-			state[:version].write_array_of_int64(version)
-			state[:data_type_length] = data_type.size
-			state[:data_type] = FFI::MemoryPointer.new(:pointer, data_type.size)
-			state.data_type_strings = data_type.map {|string| FFI::MemoryPointer.from_string(string)}
-			state[:data_type].write_array_of_pointer(state.data_type_strings)
-			state[:raw] = FFI::MemoryPointer.from_string(data)
-			state[:raw_length] = data.size
-			state
+
+	class FFIResultWithNothing < FFIResult
+		layout :status, FFIResultStatus
+
+		def unwrap
+			return nil  if self[:status].to_sym == :NotAvailable
+			raise self[:status].to_exception  if self[:status].to_sym != :Ok
+			nil
 		end
 	end
-	
-	class FFIObjectExposeStateResult < FFI::Struct
-		layout :error, :uint8, :changed, :uint8
-	end
-	
-	class FFITokioWebsocketConnectorNewResult < FFI::Struct
-		layout :error, :uint8, :websocket_connector_pointer, :pointer
+
+
+	class FFIResultWithPointer < FFIResult
+		layout :status, FFIResultStatus, :pointer, :pointer
+
+		def unwrap
+			return nil  if self[:status].to_sym == :NotAvailable
+			raise self[:status].to_exception  if self[:status].to_sym != :Ok
+			self[:pointer]
+		end
 	end
 	
-	class FFITagObserveObjectStateBorrowResult < FFI::Struct
-		layout :error, :uint8, :state, :pointer
-	end
 	
-	class FFIObjectDescriptor < FFI::Struct
-		layout :tags_count, :size_t, :tags, :pointer, :json, :pointer
-		attr_accessor :tags_strings
-		
-		def tags
-			self[:tags].read_array_of_pointer(self[:tags_count]).map { |string| JSON.parse(string.read_string()) }	# does this copy the string? 
+	class Callbacks
+
+		attr_reader :waker
+
+		def initialize
+			@queues = {}
+			@queues_sequence = 0
+			@queues_mutex = Mutex.new
+			@waker = proc { |pointer|
+				queue_id = pointer.address
+				@queues_mutex.synchronize {
+					@queues[queue_id]&.each { |queue|
+						queue << :wake
+					}
+				}
+			}
 		end
-	
-		def json
-			JSON.parse(self[:json].read_string())
+		
+		def register_queue(queue)
+			@queues_mutex.synchronize {
+				@queues_sequence = (@queues_sequence+1) % 2**32
+				queue_id = @queues_sequence
+				(@queues[queue_id] ||= Set.new) << queue
+				queue_id
+			}
 		end
-	
-		def self.construct(tags,json)
-			descriptor = FFIObjectDescriptor.new
-			descriptor[:tags_count] = tags.size
-			descriptor.tags_strings = tags.map { |tag| FFI::MemoryPointer.from_string(JSON.dump(tag)) }
-			descriptor[:tags] = FFI::MemoryPointer.new(:pointer, descriptor.tags_strings.size)
-			descriptor[:tags].write_array_of_pointer(descriptor.tags_strings)
-			descriptor[:json] = FFI::MemoryPointer.from_string(JSON.dump(json))
-			descriptor
+
+		def unregister_queue(queue_id)
+			@queues_mutex.synchronize {
+				@queues[queue_id].delete(queue_id)
+				@queues.delete(queue_id)  if @queues[queue_id].empty?
+			}
 		end
-	
 	end
+
 	
-	class FFITagDescriptor < FFI::Struct
-		layout :json, :pointer
-	
-		def json
-			JSON.parse(self[:json].read_string())
-		end
-	
-		def self.construct(json)
-			descriptor = FFITagDescriptor.new
-			descriptor[:json] = FFI::MemoryPointer.from_string(JSON.dump(json))
-			descriptor
+	class FFIFutureReturningNothing < FFI::Struct
+		layout :pointer, :pointer
+
+		@@callbacks = Callbacks.new
+
+		def self.create_and_await(owner)
+			Thread.handle_interrupt(Object => :never) {
+				begin
+					queue = queue_id = drop_locked = pointer = nil
+					Thread.handle_interrupt(Object => :immediate) {
+						queue = Queue.new
+						queue_id = @@callbacks.register_queue(queue)
+						drop_locked = owner.drop_lock(queue)
+						return nil  if !pointer = owner.with_pointer { |pointer| yield pointer }
+						loop {
+							result = owner.with_pointer { Hakuban::FFI::hakuban_future_returning_nothing_poll(pointer[:pointer],@@callbacks.waker,::FFI::Pointer.new(queue_id)) }
+							return result  if not result.is_Pending?
+							# Currently the only future returning nothing is guaranteed to complete at first poll
+							# :unreachable:
+							raise Hakuban::FFIObject::PointerAlreadyDropped  if queue.pop == :dropping
+							# :unreachable:
+						}
+					}
+				ensure
+					Hakuban::FFI::hakuban_future_returning_nothing_drop(pointer[:pointer])  if pointer
+					owner.drop_release(queue)  if drop_locked
+					@@callbacks.unregister_queue(queue_id)
+				end
+			}
 		end
-	
 	end
-	
-	
-	class FFIObjectDescriptors < FFI::Struct
-		layout :count, :size_t, :descriptors, :pointer
-	
-		def descriptors
-			self[:count].times.map { |i| FFIObjectDescriptor.new(self[:descriptors] + i * FFIObjectDescriptor.size) }
+
+
+	class FFIFutureReturningPointer < FFI::Struct
+		layout :pointer, :pointer
+
+		@@callbacks = Callbacks.new
+
+		def self.create_and_await(owner)
+			Thread.handle_interrupt(Object => :never) {
+				begin
+					queue = queue_id = drop_locked = pointer = nil
+					Thread.handle_interrupt(Object => :immediate) {
+						queue = Queue.new
+						queue_id = @@callbacks.register_queue(queue)
+						drop_locked = owner.drop_lock(queue)
+						return nil  if !pointer = owner.with_pointer { |pointer| yield pointer }
+						loop {
+							result = owner.with_pointer { Hakuban::FFI::hakuban_future_returning_pointer_poll(pointer[:pointer],@@callbacks.waker,::FFI::Pointer.new(queue_id)) }
+							return result  if not result.is_Pending?
+							raise Hakuban::FFIObject::PointerAlreadyDropped  if queue.pop == :dropping
+						}
+					}
+				ensure
+					Hakuban::FFI::hakuban_future_returning_pointer_drop(pointer[:pointer])  if pointer
+					owner.drop_release(queue)  if drop_locked
+					@@callbacks.unregister_queue(queue_id)
+				end
+			}
 		end
 	end
+
+
+	class FFIArray < FFI::Struct
+	 	layout :length, :size_t, :pointer, :pointer
+	end
 	
 
-	extend FFI::Library
+	# Every function which can cause a wake() has to be "blocking: true".
+	# Otherwise they are very likely to deadlock on GVL and other locks acquired by RemoteExchange on incomming message.
+	# FIXME: way too many functions are marked as blocking here
 
-	ffi_lib 'hakuban'
+	callback :waker, [ :pointer ], :void	
 
-	callback :object_callback, [ :pointer, FFIObjectDescriptor.by_value, :uint8 ], :void
-	#callback :tag_callback, [ :pointer, FFITagDescriptor.by_value, :uint8 ], :void
-
-	attach_function :hakuban_local_node_new, [ :string ], FFILocalNodeNewResult.by_value
-	attach_function :hakuban_local_node_drop, [ :pointer ], :void, blocking: true
-
-	attach_function :hakuban_object_observe_new, [ :pointer, FFIObjectDescriptor.by_value ], FFIObjectObserveResult.by_value, blocking: true
-	attach_function :hakuban_object_observe_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_observe_state_borrow, [ :pointer ], :pointer, blocking: true
-	attach_function :hakuban_object_observe_events_get, [ :pointer ], :pointer, blocking: true
-	                 
-	attach_function :hakuban_object_expose_new, [ :pointer, FFIObjectDescriptor.by_value], FFIObjectExposeResult.by_value, blocking: true
-	attach_function :hakuban_object_expose_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_expose_state, [ :pointer, FFIObjectExposeState.by_value, :uint64 ], FFIObjectExposeStateResult.by_value, blocking: true
-	attach_function :hakuban_object_expose_assignment, [ :pointer ], :uint64, blocking: true
-	attach_function :hakuban_object_expose_desynchronize, [ :pointer, :uint64 ], :void, blocking: true
-	attach_function :hakuban_object_expose_events_get, [ :pointer ], :pointer, blocking: true
-
-	attach_function :hakuban_tag_observe_new, [ :pointer, FFITagDescriptor.by_value ], FFITagObserveResult.by_value, blocking: true
-	attach_function :hakuban_tag_observe_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_observe_object_descriptors_borrow, [ :pointer ], FFIObjectDescriptors.by_value, blocking: true
-	attach_function :hakuban_tag_observe_object_state_borrow, [ :pointer, FFIObjectDescriptor.by_value ], FFITagObserveObjectStateBorrowResult.by_value, blocking: true
-	attach_function :hakuban_tag_observe_events_get, [ :pointer ], :pointer, blocking: true
-
-	attach_function :hakuban_tag_expose_new, [ :pointer, FFITagDescriptor.by_value ], FFITagExposeResult.by_value, blocking: true
-	attach_function :hakuban_tag_expose_drop, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_tag_expose_object_descriptors_borrow, [ :pointer ], FFIObjectDescriptors.by_value, blocking: true
-	attach_function :hakuban_tag_expose_object_state, [ :pointer, FFIObjectDescriptor.by_value, FFIObjectExposeState.by_value, :uint64 ], FFIObjectExposeStateResult.by_value, blocking: true
-	attach_function :hakuban_tag_expose_object_assignment, [ :pointer, FFIObjectDescriptor.by_value ], :uint64, blocking: true
-	attach_function :hakuban_tag_expose_object_desynchronize, [ :pointer, FFIObjectDescriptor.by_value, :uint64 ], :void, blocking: true
-	attach_function :hakuban_tag_expose_events_get, [ :pointer ], :pointer, blocking: true
-
-	attach_function :hakuban_object_observe_state_get_synchronized, [ :pointer ], :uint64
-	attach_function :hakuban_object_observe_state_get_data_version, [ :pointer ], FFIObjectObserveStateGetVersionResult.by_value
-	attach_function :hakuban_object_observe_state_get_data_type, [ :pointer ], FFIObjectObserveStateGetDataTypeResult.by_value
-	attach_function :hakuban_object_observe_state_get_data, [ :pointer ], FFIObjectObserveStateGetDataResult.by_value
-
-	attach_function :hakuban_object_descriptor_events_callback_register, [ :pointer, :object_callback, :pointer ], :pointer, blocking: true
-	attach_function :hakuban_object_descriptor_events_callback_unregister, [ :pointer ], :void, blocking: true
-	attach_function :hakuban_object_descriptor_events_return, [ :pointer ], :void, blocking: true
-
-	attach_function :hakuban_object_observe_state_return, [ :pointer ], :void
-	attach_function :hakuban_object_descriptors_return, [ FFIObjectDescriptors.by_value ], :void
+	attach_function :hakuban_logger_initialize, [ :string ], FFIResultWithNothing.by_value
 
-	attach_function :hakuban_tokio_init_multi_thread, [ :size_t ], :pointer
-	attach_function :hakuban_tokio_websocket_connector_new, [ :pointer, :pointer, :string ], FFITokioWebsocketConnectorNewResult.by_value
-	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer, :pointer ], :void, blocking: true
+	attach_function :hakuban_local_exchange_new, [ :string ], FFIResultWithPointer.by_value
+	attach_function :hakuban_local_exchange_drop, [ :pointer ], :void
+	attach_function :hakuban_local_exchange_clone, [ :pointer ], :pointer
 
-	attach_function :hakuban_logger_initialize, [ :string ], :uint8
+	attach_function :hakuban_tokio_init_multi_thread, [ :size_t ], :pointer
+	attach_function :hakuban_tokio_websocket_connector_new, [ :pointer, :pointer, :string ], FFIResultWithPointer.by_value
+	attach_function :hakuban_tokio_websocket_connector_drop, [ :pointer ], :void, blocking: true
+
+	attach_function :hakuban_object_observe_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_object_observe_contract_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_observe_contract_terminate, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_observe_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
+	attach_function :hakuban_object_observe_contract_ready, [ :pointer ], FFIResultWithPointer.by_value, blocking: true
+
+	attach_function :hakuban_object_expose_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_object_expose_contract_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_expose_contract_terminate, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_expose_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
+	attach_function :hakuban_object_expose_contract_ready, [ :pointer ], FFIResultWithPointer.by_value, blocking: true
+
+	attach_function :hakuban_tag_observe_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_tag_observe_contract_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_tag_observe_contract_terminate, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_tag_observe_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
+	attach_function :hakuban_tag_observe_contract_ready, [ :pointer ], FFIArray.by_value, blocking: true
+
+	attach_function :hakuban_tag_expose_contract_new, [ :pointer, :pointer ], :pointer, blocking: true
+	attach_function :hakuban_tag_expose_contract_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_tag_expose_contract_terminate, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_tag_expose_contract_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
+	attach_function :hakuban_tag_expose_contract_ready, [ :pointer ], FFIArray.by_value, blocking: true
+
+	attach_function :hakuban_object_state_stream_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_state_stream_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
+	attach_function :hakuban_object_state_stream_current, [ :pointer ], FFIResultWithPointer.by_value
+	attach_function :hakuban_object_state_stream_descriptor, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_state_sink_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_object_state_sink_next, [ :pointer ], FFIFutureReturningPointer.by_value, blocking: true
+	attach_function :hakuban_object_state_sink_send, [ :pointer, :pointer ], FFIFutureReturningNothing.by_value, blocking: true
+	attach_function :hakuban_object_state_sink_current, [ :pointer ], FFIResultWithPointer.by_value, blocking: true
+	attach_function :hakuban_object_state_sink_descriptor, [ :pointer ], :pointer
+	attach_function :hakuban_object_state_sink_desynchronize, [ :pointer ], :void, blocking: true
+
+	attach_function :hakuban_object_state_sink_params_drop, [ :pointer ], :void
+	attach_function :hakuban_object_state_sink_params_clone, [ :pointer ], :pointer
+
+	attach_function :hakuban_object_state_new, [ :size_t, :pointer, :size_t, :pointer, :size_t, :pointer, :uint64 ], FFIResultWithPointer.by_value
+	attach_function :hakuban_object_state_drop, [ :pointer ], :void
+	attach_function :hakuban_object_state_clone, [ :pointer ], :pointer
+	attach_function :hakuban_object_state_data, [ :pointer ], FFIArray.by_value
+	attach_function :hakuban_object_state_format, [ :pointer ], FFIArray.by_value
+	attach_function :hakuban_object_state_version, [ :pointer ], FFIArray.by_value
+	attach_function :hakuban_object_state_synchronized_ago, [ :pointer ], :uint64
+
+	attach_function :hakuban_tag_descriptor_new, [ :string ], FFIResultWithPointer.by_value
+	attach_function :hakuban_tag_descriptor_drop, [ :pointer ], :void
+	attach_function :hakuban_tag_descriptor_clone, [ :pointer ], :pointer
+	attach_function :hakuban_tag_descriptor_json, [ :pointer ], :string
+
+	attach_function :hakuban_object_descriptor_new, [ :string, :size_t, :pointer ], FFIResultWithPointer.by_value
+	attach_function :hakuban_object_descriptor_drop, [ :pointer ], :void
+	attach_function :hakuban_object_descriptor_clone, [ :pointer ], :pointer
+	attach_function :hakuban_object_descriptor_json, [ :pointer ], :string
+	attach_function :hakuban_object_descriptor_tags, [ :pointer ], FFIArray.by_value
+
+	attach_function :hakuban_future_returning_nothing_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_future_returning_pointer_drop, [ :pointer ], :void, blocking: true
+	attach_function :hakuban_future_returning_nothing_poll, [ :pointer, :waker, :pointer ], FFIResultWithNothing.by_value, blocking: true
+	attach_function :hakuban_future_returning_pointer_poll, [ :pointer, :waker, :pointer ], FFIResultWithPointer.by_value, blocking: true
+
+	attach_function :hakuban_array_drop, [ FFIArray.by_value ], :void
 
 end
+

data/lib/hakuban/logger.rb

@@ -0,0 +1,16 @@
+module Hakuban
+
+	@@logger_initialized = false
+
+	def self.logger_initialize(default_level, skip_if_already_initialized: false)
+		Hakuban::hakuban_initialize
+		if @@logger_initialized and !skip_if_already_initialized
+			raise "Logger already initialized. This can't be done more than once. Make sure logger_initialize is called before any LocalExchange gets constructed."  
+		end
+		if not @@logger_initialized
+			raise "Invalid default log level string"  if ! FFI::hakuban_logger_initialize(default_level).is_Ok?
+			@@logger_initialized = true
+		end
+	end
+
+end

data/lib/hakuban/object_state.rb

@@ -0,0 +1,106 @@
+require 'hakuban/ffi-object.rb'
+
+
+
+module Hakuban
+
+	class ObjectState < FFIObject
+
+		class WrongFormatError < Exception; end
+
+		def initialize(data, version: nil, format: nil, synchronized_us_ago: 0, &block)
+			if version.nil?
+				timestamp = Time.new
+				version = [0, timestamp.to_i, timestamp.nsec]
+			end
+			@version = version
+			@format = [format || []].flatten
+			@synchronized_us_ago = synchronized_us_ago
+			@data = data
+			@pointer = false
+			@mutex = Mutex.new
+			self.do_and_drop_or_return(&block)
+		end
+
+
+		def with_pointer
+			@mutex.synchronize {
+				raise PointerAlreadyDropped  if dropped?
+				if @pointer == false
+					Hakuban::hakuban_initialize
+					version_pointer = ::FFI::MemoryPointer.new(:int64, @version.size)
+					version_pointer.write_array_of_int64(@version)
+					format_pointer = ::FFI::MemoryPointer.new(:pointer, @format.size)
+					format_strings = format.map {|string| ::FFI::MemoryPointer.from_string(string)}
+					format_pointer.write_array_of_pointer(format_strings)
+					data_pointer = ::FFI::MemoryPointer.from_string(@data)
+					pointer = FFI::hakuban_object_state_new(@version.size, version_pointer, @format.size, format_pointer, @data.bytesize, data_pointer, @synchronized_us_ago).unwrap
+					initialize_pointer(pointer, :hakuban_object_state_drop, :hakuban_object_state_clone)
+				end
+				yield ::FFI::Pointer.new(@pointer)
+			}
+		end
+
+
+		private_class_method def self.from_ffi_pointer(pointer)
+			new_instance = allocate
+			new_instance.send(:initialize_pointer, pointer, :hakuban_object_state_drop, :hakuban_object_state_clone)
+			new_instance
+		end
+
+		def data
+			return @data  if defined? @data
+			array = with_pointer { |pointer| FFI::hakuban_object_state_data(pointer) }
+			#array[:data_bytes].read_array_of_char(array[:length]) #.pack('c*').clone()
+			@data = array[:pointer].read_string(array[:length]).clone()
+		end
+
+		def format
+			return @format  if defined? @format
+			array = with_pointer { |pointer| FFI::hakuban_object_state_format(pointer) }
+			@format = array[:pointer].read_array_of_pointer(array[:length]).map { |string| string.read_string().clone() }
+		end
+
+		def version
+			return @version  if defined? @version
+			array = with_pointer { |pointer| FFI::hakuban_object_state_version(pointer) }
+			@version = array[:pointer].read_array_of_int64(array[:length])
+		end
+
+		def synchronized_us_ago
+			return @synchronized_us_ago  if defined? @synchronized_us_ago
+			@synchronized_us_ago = with_pointer { |pointer| FFI::hakuban_object_state_synchronized_ago(pointer) }
+		end
+
+		def with_data(data)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def with_version(version)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def with_format(format)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def with_synchronized_us_ago(synchronized_us_ago)
+			ObjectState.new(data, version: version, format: format, synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def json_deserialize
+			raise WrongFormatError  if format[-1] != "JSON"
+			ObjectState.new(JSON.parse(data), version: version, format: format[0...-1], synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def json_serialize
+			ObjectState.new(JSON.dump(data), version: version, format: format+["JSON"], synchronized_us_ago: synchronized_us_ago)
+		end
+
+		def inspect
+			"#<ObjectState @synchronized=%p @version=%p>"%[synchronized_us_ago, version]
+		end
+
+	end
+	
+end

data/lib/hakuban/object_state_sink.rb

@@ -0,0 +1,64 @@
+require 'hakuban/ffi-object.rb'
+require 'hakuban/stream.rb'
+
+
+module Hakuban
+
+	class ObjectStateSink < FFIObject
+
+		private_class_method :new
+
+		def initialize(pointer)
+			initialize_pointer(pointer, :hakuban_object_state_sink_drop, nil)
+		end
+
+
+		include Stream
+
+
+		def next(&block)
+			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_object_state_sink_next(pointer) }.unwrap
+			ObjectStateSinkParams.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+
+		def current(&block)
+			return nil  if ! pointer = with_pointer { |pointer| FFI::hakuban_object_state_sink_current(pointer) }.unwrap
+			ObjectStateSinkParams.send(:new, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+
+		def send(object_state)
+			FFI::FFIFutureReturningNothing.create_and_await(self)  { |pointer| 
+				object_state.with_pointer { |object_state_pointer| FFI::hakuban_object_state_sink_send(pointer, object_state_pointer) }
+			}.unwrap
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+
+		def descriptor
+			Hakuban::ObjectDescriptor.send(:from_ffi_pointer, with_pointer { |pointer| FFI::hakuban_object_state_sink_descriptor(pointer) }) 
+		end
+		
+
+		def desynchronize
+			with_pointer { |pointer| FFI::hakuban_object_state_sink_desynchronize(pointer) }
+		rescue FFIObject::PointerAlreadyDropped
+		end
+
+	end
+
+	class ObjectStateSinkParams < FFIObject
+
+		private_class_method :new
+
+		def initialize(pointer)
+			initialize_pointer(pointer, :hakuban_object_state_sink_params_drop, :hakuban_object_state_sink_params_clone)
+		end
+
+	end
+
+
+end

data/lib/hakuban/object_state_stream.rb

@@ -0,0 +1,39 @@
+require 'hakuban/ffi-object.rb'
+require 'hakuban/stream.rb'
+
+
+module Hakuban
+
+	class ObjectStateStream < FFIObject
+
+		private_class_method :new
+		
+		def initialize(pointer)
+			initialize_pointer(pointer, :hakuban_object_state_stream_drop, nil)
+		end
+
+
+		include Stream
+
+
+		def next(&block)
+			return nil  if ! pointer = FFI::FFIFutureReturningPointer.create_and_await(self) { |pointer| FFI::hakuban_object_state_stream_next(pointer) }.unwrap
+			ObjectState.send(:from_ffi_pointer, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped	
+		end
+
+
+		def current(&block)
+			return nil  if ! pointer = with_pointer { |pointer| FFI::hakuban_object_state_stream_current(pointer) }.unwrap
+			ObjectState.send(:from_ffi_pointer, pointer).do_and_drop_or_return(&block)
+		rescue FFIObject::PointerAlreadyDropped	
+		end
+
+		
+		def descriptor
+			Hakuban::ObjectDescriptor.send(:from_ffi_pointer, with_pointer { |pointer| FFI::hakuban_object_state_stream_descriptor(pointer) })
+		end
+		
+	end
+
+end