hakuban 0.5.3 → 0.6.0

data/lib/hakuban/hakuban.rb

@@ -7,6 +7,7 @@ require_relative './ffi.rb'
 #TODO: privative methods
 #TODO: error classes
 
+#AutoPointers use proc-wrapped calls because they segfault sometimes when used with FFI::method(:xxx) (why?)
 
 module Hakuban
 
@@ -50,7 +51,7 @@ module Hakuban
 
 		attr_reader :local_node_pointer  #todo: hide
 
-		def initialize(name=nil)
+		def initialize(name: nil)
 			@default_serializer = lambda { |data_type, data| 
 				[["JSON"]+data_type, JSON.dump(data)] 
 			}
@@ -157,15 +158,16 @@ module Hakuban
 		attr_reader :tags, :json
 
 		def initialize(tags,json)
-			@tags, @json = Set.new(tags), json
+			@tags = Set.new(tags.map { |tag| tag.kind_of?(TagDescriptor) ? tag : TagDescriptor.new(tag) })
+			@json = json
 		end
 
 		def to_ffi
-			FFI::FFIObjectDescriptor.construct(@tags, @json)
+			FFI::FFIObjectDescriptor.construct(@tags.map(&:json), @json)
 		end
 
 		def self.from_ffi(ffi)
-			ObjectDescriptor.new(ffi.tags, ffi.json)
+			ObjectDescriptor.new(ffi.tags.map{ |tag| TagDescriptor.new(tag) }, ffi.json)
 		end
 
 		def ==(other)
@@ -213,38 +215,35 @@ module Hakuban
 	end
 
 
-	class EventQueue
-
-		def initialize(queue, prefix, register_method, pointer, unregister_method)
-			@queue = queue
-			@callback = EventQueue.generate_callback(@queue, prefix)
-			@registered_callback_pointer = ::FFI::AutoPointer.new(
-				register_method.call(pointer, @callback, ::FFI::Pointer::NULL), 
-				EventQueue.generate_unregister(unregister_method, @callback)
-			)
-			#puts "Allocated callback pointer: #{@registered_callback_pointer}"
-			#puts "Allocated callback queue: #{@events}"
-		end	
+	class ObjectDescriptorEvents
+		def initialize(pointer)
+			@events_pointer = ::FFI::AutoPointer.new(pointer, proc { |ptr| FFI.hakuban_object_descriptor_events_return(ptr) })
+		end
 
-		def self.generate_callback(queue, prefix)
-			proc { |_userdata, ffi_descriptor, ffi_action|
-				#puts "Callback for queue: #{queue}"
+		# WARNING: this callback may be run from a separate, non-ruby, thread
+		def callback_register(&callback)
+			ffi_callback = proc { |_userdata, ffi_descriptor, ffi_action|
 				action = Hakuban::action_int_to_symbol(ffi_action)
 				descriptor = ObjectDescriptor.from_ffi(ffi_descriptor)
-				queue << prefix + [action, descriptor]
+				callback.call(descriptor, action)
 			}
+			@callback_pointer = ::FFI::AutoPointer.new(
+				FFI::hakuban_object_descriptor_events_callback_register(@events_pointer, ffi_callback, ::FFI::Pointer::NULL),
+				proc { |ptr| FFI::hakuban_object_descriptor_events_callback_unregister(ptr) }
+			)
 		end
 
-		def self.generate_unregister(unregister_method, callback)
-			proc { |pointer|
-				#puts "Dropping callback pointer: #{pointer}"
-				callback # probably not needed, but I want to be sure this is captured
-				unregister_method.call(pointer)
-			}
+		def callback_unregister
+			@callback_pointer.free
+			@callback_pointer = nil
 		end
 
-	end
+		def drop
+			@events_pointer.free
+			@events_pointer = nil
+		end
 
+	end
 
 	class ObjectObserve
 
@@ -254,27 +253,21 @@ module Hakuban
 			@local_node, @descriptor, @deserializer = local_node, descriptor, deserializer
 			result = FFI::hakuban_object_observe_new(@local_node.local_node_pointer, descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
-			@object_observe_pointer = ::FFI::AutoPointer.new(result[:object_observe_pointer], FFI::method(:hakuban_object_observe_drop))
-			@queues = {}
+			@object_observe_pointer = ::FFI::AutoPointer.new(result[:object_observe_pointer], proc { |ptr| FFI::hakuban_object_observe_drop(ptr) })
 		end
 
 		def object_state
 			raise "Attempt to use after 'drop'"  if not @object_observe_pointer
-			ObjectObserveState.new(FFI::hakuban_object_observe_state_borrow(@object_observe_pointer), @deserializer)
-		end
-
-		def send_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_object_observe_changes_callback_register), 
-				@object_observe_pointer, 
-				FFI::method(:hakuban_object_callback_unregister)
-			)
+			if (state_ptr = FFI::hakuban_object_observe_state_borrow(@object_observe_pointer)).null?
+				nil
+			else
+				ObjectObserveState.new(state_ptr, @deserializer)
+			end
 		end
 
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @object_observe_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_object_observe_events_get(@object_observe_pointer))
 		end
 
 		def inspect
@@ -284,13 +277,10 @@ module Hakuban
 		def drop
 			@object_observe_pointer.free
 			@object_observe_pointer = nil
-			@queues.clear
 		end
 
-		def manage(manager=nil)
-			manager ||= ObjectManager.new
-			manager.contract = self
-			manager
+		def dropped?
+			@object_observe_pointer.nil?
 		end
 
 	end
@@ -305,34 +295,33 @@ module Hakuban
 			result = FFI::hakuban_object_expose_new(@local_node.local_node_pointer, descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
 			@object_expose_pointer = ::FFI::AutoPointer.new(result[:object_expose_pointer], FFI::method(:hakuban_object_expose_drop))
-			@queues = {}
 		end
 
-		def set_object_state(version, data, data_type = [])
+		def set_object_state(version, data, data_type: [], assignment: 0)
 			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
 			serialized_data_type, serialized_data = @serializer.call(data_type, data)
-			result = FFI::hakuban_object_expose_state(@object_expose_pointer, FFI::FFIObjectExposeState.construct(version, serialized_data_type, serialized_data))
+			result = FFI::hakuban_object_expose_state(@object_expose_pointer, FFI::FFIObjectExposeState.construct(version, serialized_data_type, serialized_data), assignment)
 			Hakuban::raise_if_error(result)
 			result[:changed] == 1
 		end
 
-		def assigned
+		def assignment
 			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
-			FFI::hakuban_object_expose_assigned(@object_expose_pointer) == 1
+			FFI::hakuban_object_expose_assignment(@object_expose_pointer)
 		end
 
-		def send_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_object_expose_changes_callback_register), 
-				@object_expose_pointer,
-				FFI::method(:hakuban_object_callback_unregister)
-			)
+		def assigned?
+			assignment > 0
+		end
+		
+		def desynchronize(assignment)
+			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
+			FFI::hakuban_object_expose_desynchronize(@object_expose_pointer, assignment)
 		end
 
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @object_expose_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_object_expose_events_get(@object_expose_pointer))
 		end
 
 		def inspect
@@ -342,13 +331,10 @@ module Hakuban
 		def drop
 			@object_expose_pointer.free
 			@object_expose_pointer = nil
-			@queues.clear
 		end
 
-		def manage(manager=nil)
-			manager ||= ObjectManager.new
-			manager.contract = self
-			manager
+		def dropped?
+			@object_expose_pointer.nil?
 		end
 
 	end
@@ -356,25 +342,41 @@ module Hakuban
 
 	class ObjectObserveState
 
-		attr_reader :data, :data_type, :data_version, :synchronized
-
-		def initialize(raw_state, deserializer)
-			@raw_state = raw_state
-			@synchronized = (raw_state[:synchronized] == 1)
-			@data_version = raw_state[:version].read_array_of_type(::FFI::TYPE_INT64, :read_int64, raw_state[:version_length])  if not raw_state[:version].null?
-			serialized_data_type = raw_state[:data_type].read_array_of_pointer(raw_state[:data_type_length]).map { |string| string.read_string() }
-			@data_type, @data = deserializer.call(serialized_data_type, raw_state[:raw].read_string_length(raw_state[:raw_length]))  if not raw_state[:raw].null?
-			ObjectSpace.define_finalizer(self, ObjectObserveState.finalize(@raw_state))
+		def initialize(state, deserializer)
+			@state, @deserializer = state, deserializer
+			ObjectSpace.define_finalizer(self, ObjectObserveState.finalize(@state))
 		end
 
-		def ObjectObserveState.finalize(raw_state)
+		def ObjectObserveState.finalize(state)
 			proc { |_|
-				FFI::hakuban_object_observe_state_return(raw_state)
+				FFI::hakuban_object_observe_state_return(state)
 			}
 		end
 
 		def version
-			@data_version
+			return @data_version  if @data_version
+			ffi_version = FFI::hakuban_object_observe_state_get_data_version(@state)
+			@data_version = ffi_version[:version_elements].read_array_of_type(::FFI::TYPE_INT64, :read_int64, ffi_version[:version_length])
+		end
+
+		def data
+			return @data  if @data
+			ffi_data = FFI::hakuban_object_observe_state_get_data(@state)
+			ffi_data_type = FFI::hakuban_object_observe_state_get_data_type(@state)
+			serialized_data_type = ffi_data_type[:type_elements].read_array_of_pointer(ffi_data_type[:type_length]).map { |string| string.read_string() }
+			@data_type, @data = @deserializer.call(serialized_data_type, ffi_data[:data_bytes].read_string_length(ffi_data[:data_length]))
+			@data
+		end
+
+		def data_type
+			return @data_type  if @data_type
+			data
+			@data_type
+		end
+
+		def synchronized
+			return @synchronized  if @synchronized
+			@synchronized = FFI::hakuban_object_observe_state_get_synchronized(@state)
 		end
 
 		def inspect
@@ -393,7 +395,6 @@ module Hakuban
 			result = FFI::hakuban_tag_observe_new(@local_node.local_node_pointer, @descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
 			@tag_observe_pointer = ::FFI::AutoPointer.new(result[:tag_observe_pointer], FFI::method(:hakuban_tag_observe_drop))
-			@queues = {}
 		end
 
 		def object_descriptors
@@ -412,34 +413,18 @@ module Hakuban
 			ObjectObserveState.new(result[:state], @deserializer)
 		end
 
-		def send_events_to(*params)
-			self.send_objects_events_to(*params)
-		end
-
-		def send_objects_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_tag_observe_objects_changes_callback_register), 
-				@tag_observe_pointer, 
-				FFI::method(:hakuban_object_callback_unregister)
-			)
-		end
-
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @tag_observe_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_tag_observe_events_get(@tag_observe_pointer))
 		end
 
 		def drop
 			@tag_observe_pointer.free
 			@tag_observe_pointer = nil
-			@queues.clear
 		end
 
-		def manage(manager=nil)
-			manager ||= ObjectManager.new
-			manager.contract = self
-			manager
+		def dropped?
+			@tag_observe_pointer.nil?
 		end
 
 	end
@@ -454,7 +439,6 @@ module Hakuban
 			result = FFI::hakuban_tag_expose_new(@local_node.local_node_pointer, descriptor.to_ffi)
 			Hakuban::raise_if_error(result)
 			@tag_expose_pointer = ::FFI::AutoPointer.new(result[:tag_expose_pointer], FFI::method(:hakuban_tag_expose_drop))
-			@queues = {}
 		end
 
 		def object_descriptors
@@ -465,42 +449,41 @@ module Hakuban
 			ret
 		end
 		
-		def set_object_state(object_descriptor, version, data, data_type = [])
+		def set_object_state(object_descriptor, version, data, data_type: [], assignment: 0)
 			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			raise if not version #TODO: replace this by type check
 			serialized_data_type, serialized_data = @serializer.call(data_type, data)
-			result = FFI::hakuban_tag_expose_object_state(@tag_expose_pointer, object_descriptor.to_ffi, FFI::FFIObjectExposeState.construct(version, serialized_data_type, serialized_data))
+			result = FFI::hakuban_tag_expose_object_state(@tag_expose_pointer, object_descriptor.to_ffi, FFI::FFIObjectExposeState.construct(version, serialized_data_type, serialized_data), assignment)
 			Hakuban::raise_if_error(result)
 			result[:changed] == 1
 		end
 
-		def send_events_to(*params)
-			self.send_objects_events_to(*params)
+		def assignment(object_descriptor)
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			FFI::hakuban_tag_expose_object_assignment(@tag_expose_pointer, object_descriptor.to_ffi)
 		end
 
-		def send_objects_events_to(queue, *prefix)
-			@queues[queue] = EventQueue.new(
-				queue,
-				prefix,
-				FFI::method(:hakuban_tag_expose_objects_changes_callback_register), 
-				@tag_expose_pointer, 
-				FFI::method(:hakuban_object_callback_unregister)
-			)
+		def assigned?(object_descriptor)
+			assignment(object_descriptor) > 0
+		end
+
+		def desynchronize(object_descriptor, assignment)
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			FFI::hakuban_tag_expose_object_desynchronize(@tag_expose_pointer, object_descriptor.to_ffi, assignment)
 		end
 
-		def stop_sending_objects_events_to(queue)
-			@queues.delete(queue)
+		def events
+			raise "Attempt to use after 'drop'"  if not @tag_expose_pointer
+			ObjectDescriptorEvents.new(FFI::hakuban_tag_expose_events_get(@tag_expose_pointer))
 		end
 
 		def drop
 			@tag_expose_pointer.free
 			@tag_expose_pointer = nil
-			@queues.clear
 		end
 
-		def manage(manager=nil)
-			manager ||= ObjectManager.new
-			manager.contract = self
-			manager
+		def dropped?
+			@tag_expose_pointer.nil?
 		end
 
 	end
@@ -544,150 +527,4 @@ module Hakuban
 	end
 
 
-	# convenience utils
-
-	#TODO: replace this mess (<Hash, dynamic mixins) with some "deref"
-	class ObjectManager < Hash
-
-		module ObservedObjectManager
-			def descriptor;                             self.values.first.descriptor;              end
-			def state;                                  self.values.first.state;                   end
-			def data;                                   self.values.first.data;                    end
-			def version;                                self.values.first.verison;                 end
-			def synchronized;                           self.values.first.synchronized;            end
-			def construct_object(contract, descriptor); ObservedObject.new(contract, descriptor);  end
-		end
-
-		module ExposedObjectManager
-			def descriptor;                             self.values.first.descriptor;              end
-			def state=(params);                         self.values.first.state = params;          end
-			def data=(params);                          self.values.first.data = params;           end
-			def state_set(params);                      self.values.first.state_set(params);       end
-			def data_set(params);                       self.values.first.data_set(params);        end
-			def construct_object(contract, descriptor); ExposedObject.new(contract, descriptor);   end
-		end
-
-		module ObservedTagManager
-			def construct_object(contract, descriptor); ObservedObject.new(contract, descriptor);  end
-		end
-
-		module ExposedTagManager
-			def construct_object(contract, descriptor); ExposedObject.new(contract, descriptor);  end
-		end
-		
-		attr_reader :objects, :contract
-
-		def contract=(contract)
-			raise "You can't change contracts, sorry."  if @contract
-			@contract = contract
-			case @contract.class.name
-				when "Hakuban::ObjectObserve" then singleton_class.include(ObservedObjectManager)
-				when "Hakuban::ObjectExpose"  then singleton_class.include(ExposedObjectManager)
-				when "Hakuban::TagObserve" then singleton_class.include(ObservedTagManager)
-				when "Hakuban::TagExpose" then singleton_class.include(ExposedTagManager)
-				else raise
-			end
-
-			@queue = Queue.new
-			@contract.send_events_to(@queue, :object)
-			if @contract.kind_of?(ObjectObserve) or @contract.kind_of?(ObjectExpose)
-				event, param, descriptor = @queue.pop				 
-				raise if event != :object or param != :insert or not descriptor
-				self[descriptor] = self.construct_object(@contract, descriptor)
-			end
-
-			@thread = Thread.new {
-				loop {
-					event,param,descriptor = @queue.shift
-					case [event, param]
-					when [:control, :quit]
-						break
-					when [:object, :insert]
-						self[descriptor] = construct_object(@contract, descriptor)
-						object_insert(self[descriptor])
-					when [:object, :change]
-						object_change(self[descriptor])
-					when [:object, :remove]
-						object_remove(delete(descriptor))
-					end
-				}
-			}
-		end
-
-
-		def object_insert(object)
-			# noop default
-		end
-
-		def object_change(object)
-			# noop default
-		end
-
-		def object_remove(object)
-			# noop default
-		end
-
-
-		def drop
-			@contract.stop_sending_objects_events_to(@queue)
-			@queue.push [:control, :quit]
-			@thread.join
-			@queue, @contract, @thread, @objects = nil, nil, nil, {}
-		end
-
-
-		class ManagedObject < OpenStruct
-			attr_reader :contract, :descriptor
-			def initialize(contract, descriptor)
-				@contract, @descriptor = contract, descriptor
-				super()
-			end
-		end	
-
-		#TODO: remove the arity thing...
-		class ObservedObject < ManagedObject
-			def state
-				if @contract.method(:object_state).arity == 1
-					@contract.object_state(@descriptor)
-				else
-					@contract.object_state
-				end
-			end
-			def data
-				if @contract.method(:object_state).arity == 1
-					@contract.object_state(@descriptor)&.data
-				else
-					@contract.object_state&.data
-				end
-			end
-		end
-
-		class ExposedObject < ManagedObject
-			def state_set(state)
-				if @contract.method(:set_object_state).arity == -4
-					@contract.set_object_state(@descriptor, *state)
-				else
-					@contract.set_object_state(*state)
-				end
-			end
-			def state=(state)
-				state_set(state)
-			end
-			def data_set(value)
-				timestamp = Time.new.to_f
-				if @contract.method(:set_object_state).arity == -4
-					@contract.set_object_state(@descriptor,[1, timestamp.floor, ((timestamp - timestamp.floor)*1000000000).floor, 0],value)
-				else 
-					@contract.set_object_state([1, timestamp.floor, ((timestamp - timestamp.floor)*1000000000).floor, 0],value)
-				end
-			end
-			def data=(value)
-				data_set(value)
-			end
-		end
-	end
-
-
-
-
 end