babeltrace2 0.1.0

data/lib/babeltrace2/trace-ir/trace.rb

@@ -0,0 +1,321 @@
+module Babeltrace2
+
+  attach_function :bt_trace_create,
+                  [ :bt_trace_class_handle ],
+                  :bt_trace_handle
+
+  attach_function :bt_trace_borrow_class,
+                  [ :bt_trace_handle ],
+                  :bt_trace_class_handle
+
+  attach_function :bt_trace_borrow_class_const,
+                  [ :bt_trace_handle ],
+                  :bt_trace_class_handle
+
+  attach_function :bt_trace_get_stream_count,
+                  [ :bt_trace_handle ],
+                  :uint64
+
+  attach_function :bt_trace_borrow_stream_by_index,
+                  [ :bt_trace_handle, :uint64 ],
+                  :bt_stream_handle
+
+  attach_function :bt_trace_borrow_stream_by_index_const,
+                  [ :bt_trace_handle, :uint64 ],
+                  :bt_stream_handle
+
+  attach_function :bt_trace_borrow_stream_by_id,
+                  [ :bt_trace_handle, :uint64 ],
+                  :bt_stream_handle
+
+  attach_function :bt_trace_borrow_stream_by_id_const,
+                  [ :bt_trace_handle, :uint64 ],
+                  :bt_stream_handle
+
+  attach_function :bt_trace_get_name,
+                  [ :bt_trace_handle ],
+                  :string
+
+  BT_TRACE_SET_NAME_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BTTraceSetNameStatus = enum :bt_trace_set_name_status,
+    [ :BT_TRACE_SET_NAME_STATUS_OK,
+       BT_TRACE_SET_NAME_STATUS_OK,
+      :BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR,
+       BT_TRACE_SET_NAME_STATUS_MEMORY_ERROR ]
+
+  attach_function :bt_trace_set_name,
+                  [ :bt_trace_handle, :string ],
+                  :bt_trace_set_name_status
+
+  attach_function :bt_trace_set_uuid,
+                  [ :bt_trace_handle, :bt_uuid ],
+                  :void
+
+  attach_function :bt_trace_get_uuid,
+                  [ :bt_trace_handle ],
+                  :bt_uuid
+
+  BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BTTraceSetEnvironmentEntryStatus = enum :bt_trace_set_environment_entry_status,
+    [ :BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_OK,
+       BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_OK,
+      :BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR,
+       BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_MEMORY_ERROR ]
+
+  attach_function :bt_trace_set_environment_entry_integer,
+                  [ :bt_trace_handle, :string, :int64 ],
+                  :bt_trace_set_environment_entry_status
+
+  attach_function :bt_trace_set_environment_entry_string,
+                  [ :bt_trace_handle, :string, :string ],
+                  :bt_trace_set_environment_entry_status
+
+  attach_function :bt_trace_get_environment_entry_count,
+                  [ :bt_trace_handle ],
+                  :uint64
+
+  attach_function :bt_trace_borrow_environment_entry_by_index_const,
+                  [ :bt_trace_handle, :uint64, :pointer, :pointer ],
+                  :void
+
+  attach_function :bt_trace_borrow_environment_entry_value_by_name_const,
+                  [ :bt_trace_handle, :string ],
+                  :bt_value_handle
+
+  attach_function :bt_trace_set_user_attributes,
+                  [ :bt_trace_handle, :bt_value_map_handle ],
+                  :void
+
+  attach_function :bt_trace_borrow_user_attributes,
+                  [ :bt_trace_handle ],
+                  :bt_value_map_handle
+
+  attach_function :bt_trace_borrow_user_attributes_const,
+                  [ :bt_trace_handle ],
+                  :bt_value_map_handle
+
+  callback :bt_trace_destruction_listener_func,
+           [ :bt_trace_handle, :pointer],
+           :void
+
+  def self._wrap_trace_destruction_listener_func(method)
+    method_wrapper = lambda { |trace, user_data|
+      begin
+        method.call(BTTrace.new(trace,
+                    retain: false, auto_release: false), user_data)
+      rescue Exception => e
+        puts e
+      end
+    }
+    method_wrapper
+  end
+
+  BT_TRACE_ADD_LISTENER_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_TRACE_ADD_LISTENER_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BTTraceAddListenerStatus = enum :bt_trace_add_listener_status,
+    [ :BT_TRACE_ADD_LISTENER_STATUS_OK,
+       BT_TRACE_ADD_LISTENER_STATUS_OK,
+      :BT_TRACE_ADD_LISTENER_STATUS_MEMORY_ERROR,
+       BT_TRACE_ADD_LISTENER_STATUS_MEMORY_ERROR ]
+
+  attach_function :bt_trace_add_destruction_listener,
+                  [ :bt_trace_handle, :bt_trace_destruction_listener_func,
+                    :pointer, :pointer ],
+                  :bt_trace_add_listener_status
+
+  BT_TRACE_REMOVE_LISTENER_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_TRACE_REMOVE_LISTENER_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BTTraceRemoveListenerStatus = enum :bt_trace_remove_listener_status,
+    [ :BT_TRACE_REMOVE_LISTENER_STATUS_OK,
+       BT_TRACE_REMOVE_LISTENER_STATUS_OK,
+      :BT_TRACE_REMOVE_LISTENER_STATUS_MEMORY_ERROR,
+       BT_TRACE_REMOVE_LISTENER_STATUS_MEMORY_ERROR ]
+
+  attach_function :bt_trace_remove_destruction_listener,
+                  [ :bt_trace_handle, :bt_listener_id ],
+                  :bt_trace_remove_listener_status
+
+  attach_function :bt_trace_get_ref,
+                  [ :bt_trace_handle ],
+                  :void
+
+  attach_function :bt_trace_put_ref,
+                  [ :bt_trace_handle ],
+                  :void
+
+  class BTTrace < BTSharedObject
+    SetNameStatus = BTTraceSetNameStatus
+    SetEnvironmentEntryStatus = BTTraceSetEnvironmentEntryStatus
+    AddListenerStatus = BTTraceAddListenerStatus
+    RemoveListenerStatus = BTTraceRemoveListenerStatus
+    @get_ref = :bt_trace_get_ref
+    @put_ref = :bt_trace_put_ref
+
+    def initialize(handle = nil, retain: true, auto_release: true,
+                   trace_class: nil)
+      if(handle)
+        super(handle, retain: retain, auto_release: auto_release)
+      else
+        handle = Babeltrace2.bt_trace_create(trace_class)
+        raise Babeltrace2.process_error if handle.null?
+        super(handle, retain: false)
+      end
+    end
+
+    def get_class
+      BTTraceClass.new(
+        Babeltrace2.bt_trace_borrow_class(@handle), retain: true)
+    end
+
+    def get_stream_count
+      Babeltrace2.bt_trace_get_stream_count(@handle)
+    end
+    alias stream_count get_stream_count
+
+    def get_stream_by_index(index)
+      return nil if index >= get_stream_count
+      BTStream.new(
+        Babeltrace2.bt_trace_borrow_stream_by_index(@handle, index), retain: true)
+    end
+
+    def get_stream_by_id(id)
+      handle = Babeltrace2.bt_trace_borrow_stream_by_id(@handle, id)
+      return nil if handle.null?
+      BTStream.new(handle, retain: true)
+    end
+
+    def set_name(name)
+      res = Babeltrace2.bt_trace_set_name(@handle, name)
+      raise Babeltrace2.process_error(res) if res != :BT_TRACE_SET_NAME_STATUS_OK
+      self
+    end
+
+    def name=(name)
+      set_name(name)
+      name
+    end
+
+    def get_name
+      Babeltrace2.bt_trace_get_name(@handle)
+    end
+    alias name get_name
+
+    def set_uuid(uuid)
+      Babeltrace2.bt_trace_set_uuid(@handle, uuid)
+      self
+    end
+
+    def uuid=(uuid)
+      set_uuid(uuid)
+      uuid
+    end
+
+    def get_uuid
+      uuid = Babeltrace2.bt_trace_get_uuid(@handle)
+      return nil if uuid.null?
+      uuid
+    end
+    alias uuid get_uuid
+
+    def set_environment_entry_integer(name, value)
+      res = Babeltrace2.bt_trace_set_environment_entry_integer(@handle, name, value)
+      raise Babeltrace2.process_error(res) if res != :BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_OK
+      self
+    end
+
+    def set_environment_entry_string(name, value)
+      res = Babeltrace2.bt_trace_set_environment_entry_string(@handle, name, value)
+      raise Babeltrace2.process_error(res) if res != :BT_TRACE_SET_ENVIRONMENT_ENTRY_STATUS_OK
+      self
+    end
+
+    def get_environment_entry_count
+      Babeltrace2.bt_trace_get_environment_entry_count(@handle)
+    end
+    alias environment_entry_count get_environment_entry_count
+
+    def get_environement_entry_by_index(index)
+      return nil if index >= get_environment_entry_count
+      ptr1 = FFI::MemoryPointer.new(:pointer)
+      ptr2 = FFI::MemoryPointer.new(:pointer)
+      Babeltrace2.bt_trace_borrow_environment_entry_by_index_const(
+        @handle, index, ptr1, ptr2)
+      name = ptr1.read_pointer.read_string
+      value = BTValue.from_handle(BTValueHandle.new(ptr2.read_pointer))
+      return [name, value]
+    end
+
+    def get_environment_entry_value_by_name(name)
+      handle = Babeltrace2.bt_trace_borrow_environment_entry_value_by_name_const(
+                 @handle, name)
+      return nil if handle.null?
+      BTValue.from_handle(handle)
+    end
+
+    def get_environment
+      get_environment_entry_count.times.collect { |index|
+        get_environement_entry_by_index(index)
+      }.collect { |name, value| [name, value.value] }.to_h
+    end
+    alias environment get_environment
+
+    def set_environement(hash)
+      hash.each { |k, v|
+        case v
+        when String
+          set_environment_entry_string(k, v)
+        when Integer
+          set_environment_entry_integer(k, v)
+        else
+          raise "invalid value type"
+        end
+      }
+      self
+    end
+
+    def environment=(hash)
+      set_environement(hash)
+      hash
+    end
+
+    def set_user_attributes(user_attributes)
+      Babeltrace2.bt_trace_set_user_attributes(@handle, BTValue.from_value(user_attributes))
+      self
+    end
+
+    def user_attributes=(user_attributes)
+      set_user_attributes(user_attributes)
+      user_attributes
+    end
+
+    def get_user_attributes
+      BTValueMap.new(Babeltrace2.bt_trace_borrow_user_attributes(@handle), retain: true)
+    end
+    alias user_attributes get_user_attributes
+
+    def add_destruction_listener(user_func, user_data: nil)
+      user_func = Babeltrace2._wrap_trace_destruction_listener_func(user_func)
+      id = @handle.to_i
+      ptr = FFI::MemoryPointer.new(:uint64)
+      res = Babeltrace2.bt_trace_add_destruction_listener(@handle, user_func, user_data, ptr)
+      raise Babeltrace2.process_error(res) if res != :BT_TRACE_ADD_LISTENER_STATUS_OK
+      listener_id = ptr.read_uint64
+      h = Babeltrace2._callbacks[id][:destruction_listener_funcs]
+      if h.nil?
+        h = {}
+        Babeltrace2._callbacks[id][:destruction_listener_funcs] = h
+      end
+      h[listener_id] = [user_func, user_data]
+      listener_id
+    end
+
+    def remove_destruction_listener(listener_id)
+      res = Babeltrace2.bt_trace_remove_destruction_listener(@handle, listener_id)
+      raise Babeltrace2.process_error(res) if res != :BT_TRACE_REMOVE_LISTENER_STATUS_OK
+      Babeltrace2._callbacks[@handle.to_i][:destruction_listener_funcs].delete(listener_id)
+      self
+    end
+  end
+end

data/lib/babeltrace2/types.rb

@@ -0,0 +1,667 @@
+module Babeltrace2
+
+  class BTHandle < FFI::Pointer
+    extend FFI::DataConverter
+    class << self
+      def native_type
+        FFI::Type::POINTER
+      end
+
+      def from_native(value, context)
+        new(value) #value.null? ? nil : new(value)
+      end
+
+      def to_native(value, context)
+        unless value.nil?
+          p = value.to_ptr
+          raise "invalid type #{p.class}, expected #{self}" unless p.kind_of?(self)
+          p
+        else
+          nil
+        end
+      end
+    end
+  end
+
+  class BTClockClassHandle < BTHandle; end
+  typedef BTClockClassHandle, :bt_clock_class_handle
+
+  class BTClockSnapshotHandle < BTHandle; end
+  typedef BTClockSnapshotHandle, :bt_clock_snapshot_handle
+
+  class BTComponentClassHandle < BTHandle; end
+  typedef BTComponentClassHandle, :bt_component_class_handle
+
+  class BTComponentClassFilterHandle < BTComponentClassHandle; end
+  typedef BTComponentClassFilterHandle, :bt_component_class_filter_handle
+
+  class BTComponentClassSinkHandle < BTComponentClassHandle; end
+  typedef BTComponentClassSinkHandle, :bt_component_class_sink_handle
+
+  class BTComponentClassSourceHandle < BTComponentClassHandle; end
+  typedef BTComponentClassSourceHandle, :bt_component_class_source_handle
+
+  class BTComponentDescriptorSetHandle < BTHandle; end
+  typedef BTComponentDescriptorSetHandle, :bt_component_descriptor_set_handle
+
+  class BTComponentHandle < BTHandle; end
+  typedef BTComponentHandle, :bt_component_handle
+
+  class BTComponentFilterHandle < BTComponentHandle; end
+  typedef BTComponentFilterHandle, :bt_component_filter_handle
+
+  class BTComponentSinkHandle < BTComponentHandle; end
+  typedef BTComponentSinkHandle, :bt_component_sink_handle
+
+  class BTComponentSourceHandle < BTComponentHandle; end
+  typedef BTComponentSourceHandle, :bt_component_source_handle
+
+  class BTConnectionHandle < BTHandle; end
+  typedef BTConnectionHandle, :bt_connection_handle
+
+  class BTErrorHandle < BTHandle; end
+  typedef BTErrorHandle, :bt_error_handle
+
+  class BTErrorCauseHandle < BTHandle; end
+  typedef BTErrorCauseHandle, :bt_error_cause_handle
+
+  class BTEventHandle < BTHandle; end
+  typedef BTEventHandle, :bt_event_handle
+
+  class BTEventClassHandle < BTHandle; end
+  typedef BTEventClassHandle, :bt_event_class_handle
+
+  class BTEventHeaderFieldHandle < BTHandle; end
+  typedef BTEventHeaderFieldHandle, :bt_event_header_field_handle
+
+  class BTFieldHandle < BTHandle; end
+  typedef BTFieldHandle, :bt_field_handle
+
+  class BTFieldClassHandle < BTHandle; end
+  typedef BTFieldClassHandle, :bt_field_class_handle
+
+  class BTFieldClassEnumerationMappingHandle < BTHandle; end
+  typedef BTFieldClassEnumerationMappingHandle,
+          :bt_field_class_enumeration_mapping_handle
+
+  class BTFieldClassEnumerationSignedMappingHandle <
+        BTFieldClassEnumerationMappingHandle; end
+  typedef BTFieldClassEnumerationSignedMappingHandle,
+          :bt_field_class_enumeration_signed_mapping_handle
+
+  class BTFieldClassEnumerationUnsignedMappingHandle <
+        BTFieldClassEnumerationMappingHandle; end
+  typedef BTFieldClassEnumerationUnsignedMappingHandle,
+          :bt_field_class_enumeration_unsigned_mapping_handle
+
+  class BTFieldClassStructureMemberHandle < BTHandle; end
+  typedef BTFieldClassStructureMemberHandle, :bt_field_class_structure_member_handle
+
+  class BTFieldClassVariantOptionHandle < BTHandle; end
+  typedef BTFieldClassVariantOptionHandle, :bt_field_class_variant_option_handle
+
+  class BTFieldClassVariantWithSelectorFieldIntegerSignedOptionHandle <
+        BTFieldClassVariantOptionHandle; end
+  typedef BTFieldClassVariantWithSelectorFieldIntegerSignedOptionHandle,
+          :bt_field_class_variant_with_selector_field_integer_signed_option_handle
+
+  class BTFieldClassVariantWithSelectorFieldIntegerUnsignedOptionHandle <
+        BTFieldClassVariantOptionHandle; end
+  typedef BTFieldClassVariantWithSelectorFieldIntegerUnsignedOptionHandle,
+          :bt_field_class_variant_with_selector_field_integer_unsigned_option_handle
+
+  class BTFieldPathHandle < BTHandle; end
+  typedef BTFieldPathHandle, :bt_field_path_handle
+
+  class BTFieldPathItemHandle < BTHandle; end
+  typedef BTFieldPathItemHandle, :bt_field_path_item_handle
+
+  class BTGraphHandle < BTHandle; end
+  typedef BTGraphHandle, :bt_graph_handle
+
+  class BTIntegerRangeSetHandle < BTHandle; end
+  typedef BTIntegerRangeSetHandle, :bt_integer_range_set_handle
+
+  class BTIntegerRangeSetSignedHandle < BTIntegerRangeSetHandle; end
+  typedef BTIntegerRangeSetSignedHandle, :bt_integer_range_set_signed_handle
+
+  class BTIntegerRangeSetUnsignedHandle < BTIntegerRangeSetHandle; end
+  typedef BTIntegerRangeSetUnsignedHandle, :bt_integer_range_set_unsigned_handle
+
+  class BTIntegerRangeSignedHandle < BTHandle; end
+  typedef BTIntegerRangeSignedHandle, :bt_integer_range_signed_handle
+
+  class BTIntegerRangeUnsignedHandle < BTHandle; end
+  typedef BTIntegerRangeUnsignedHandle, :bt_integer_range_unsigned_handle
+
+  class BTInterrupterHandle < BTHandle; end
+  typedef BTInterrupterHandle, :bt_interrupter_handle
+
+  class BTMessageHandle < BTHandle; end
+  typedef BTMessageHandle, :bt_message_handle
+
+  class BTMessageIteratorHandle < BTHandle; end
+  typedef BTMessageIteratorHandle, :bt_message_iterator_handle
+
+  class BTMessageIteratorClassHandle < BTHandle; end
+  typedef BTMessageIteratorClassHandle, :bt_message_iterator_class_handle
+
+  class BTObjectHandle < BTHandle; end
+  typedef BTObjectHandle, :bt_object_handle
+
+  class BTPacketHandle < BTHandle; end
+  typedef BTPacketHandle, :bt_packet_handle
+
+  class BTPortHandle < BTHandle; end
+  typedef BTPortHandle, :bt_port_handle
+
+  class BTPortInputHandle < BTPortHandle; end
+  typedef BTPortInputHandle, :bt_port_input_handle
+
+  class BTPortOutputHandle < BTPortHandle; end
+  typedef BTPortOutputHandle, :bt_port_output_handle
+
+  class BTPortOutputMessageIteratorHandle < BTMessageIteratorHandle; end
+  typedef BTPortOutputMessageIteratorHandle, :bt_port_output_message_iterator_handle
+
+  class BTQueryExecutorHandle < BTHandle; end
+  typedef BTQueryExecutorHandle, :bt_query_executor_handle
+
+  class BTPrivateQueryExecutorHandle < BTQueryExecutorHandle; end
+  typedef BTPrivateQueryExecutorHandle, :bt_private_query_executor_handle
+
+  module BTSelfComponentHandle; end
+  class BTSelfComponentHandleCls < BTComponentHandle
+    include BTSelfComponentHandle
+    class << self
+      def to_native(value, context)
+        unless value.nil?
+          p = value.to_ptr
+          raise "invalid type #{p.class}, expected #{BTSelfComponentHandle}" unless p.kind_of?(BTSelfComponentHandle)
+          p
+        else
+          nil
+        end
+      end
+    end
+  end
+  typedef BTSelfComponentHandleCls, :bt_self_component_handle
+
+  class BTSelfComponentFilterHandle < BTComponentFilterHandle
+    include BTSelfComponentHandle
+  end
+  typedef BTSelfComponentFilterHandle, :bt_self_component_filter_handle
+
+  class BTSelfComponentFilterConfigurationHandle < BTHandle; end
+  typedef BTSelfComponentFilterConfigurationHandle,
+          :bt_self_component_filter_configuration_handle
+
+  class BTSelfComponentSinkHandle < BTComponentSinkHandle
+    include BTSelfComponentHandle
+  end
+  typedef BTSelfComponentSinkHandle, :bt_self_component_sink_handle
+
+  class BTSelfComponentSinkConfigurationHandle < BTHandle; end
+  typedef BTSelfComponentSinkConfigurationHandle,
+          :bt_self_component_sink_configuration_handle
+
+  class BTSelfComponentSourceHandle < BTComponentSourceHandle
+    include BTSelfComponentHandle
+  end
+  typedef BTSelfComponentSourceHandle, :bt_self_component_source_handle
+
+  class BTSelfComponentSourceConfigurationHandle < BTHandle; end
+  typedef BTSelfComponentSourceConfigurationHandle,
+          :bt_self_component_source_configuration_handle
+
+  module BTSelfComponentClassHandle; end
+  class BTSelfComponentClassHandleCls < BTComponentClassHandle
+    include BTSelfComponentClassHandle
+    class << self
+      def to_native(value, context)
+        unless value.nil?
+          p = value.to_ptr
+          raise "invalid type #{p.class}, expected #{BTSelfComponentClassHandle}" unless p.kind_of?(BTSelfComponentClassHandle)
+          p
+        else
+          nil
+        end
+      end
+    end
+  end
+  typedef BTSelfComponentClassHandleCls,
+          :bt_self_component_class_handle
+
+  class BTSelfComponentClassFilterHandle < BTComponentClassFilterHandle
+    include BTSelfComponentClassHandle
+  end
+  typedef BTSelfComponentClassFilterHandle,
+          :bt_self_component_class_filter_handle
+
+  class BTSelfComponentClassSinkHandle < BTComponentClassSinkHandle
+    include BTSelfComponentClassHandle
+  end
+  typedef BTSelfComponentClassSinkHandle,
+          :bt_self_component_class_sink_handle
+
+  class BTSelfComponentClassSourceHandle < BTComponentClassSourceHandle
+    include BTSelfComponentClassHandle
+  end
+  typedef BTSelfComponentClassSourceHandle,
+          :bt_self_component_class_source_handle
+
+  module BTSelfComponentPortHandle; end
+  class BTSelfComponentPortHandleCls < BTPortHandle
+    include BTSelfComponentPortHandle
+    class << self
+      def to_native(value, context)
+        unless value.nil?
+          p = value.to_ptr
+          raise "invalid type #{p.class}, expected #{BTSelfComponentPortHandle}" unless p.kind_of?(BTSelfComponentPortHandle)
+          p
+        else
+          nil
+        end
+      end
+    end
+  end
+  typedef BTSelfComponentPortHandleCls, :bt_self_component_port_handle
+
+  class BTSelfComponentPortInputHandle < BTPortInputHandle
+    include BTSelfComponentPortHandle
+  end
+  typedef BTSelfComponentPortInputHandle, :bt_self_component_port_input_handle
+
+  class BTSelfComponentPortOutputHandle < BTPortOutputHandle
+    include BTSelfComponentPortHandle
+  end
+  typedef BTSelfComponentPortOutputHandle, :bt_self_component_port_output_handle
+
+  class BTMessageIteratorHandle < BTHandle; end
+  typedef BTMessageIteratorHandle, :bt_message_iterator_handle
+
+  class BTSelfMessageIteratorHandle < BTMessageIteratorHandle; end
+  typedef BTSelfMessageIteratorHandle, :bt_self_message_iterator_handle
+
+  class BTSelfMessageIteratorConfigurationHandle < BTHandle; end
+  typedef BTSelfMessageIteratorConfigurationHandle, :bt_self_message_iterator_configuration_handle
+
+  class BTPluginHandle < BTHandle; end
+  typedef BTPluginHandle, :bt_plugin_handle
+
+  class BTPluginSetHandle < BTHandle; end
+  typedef BTPluginSetHandle, :bt_plugin_set_handle
+
+  class BTPluginSoSharedLibHandleHandle < BTHandle; end
+  typedef BTPluginSoSharedLibHandleHandle, :bt_plugin_so_shared_lib_handle_handle
+
+  class BTSelfPluginHandle < BTPluginHandle; end
+  typedef BTSelfPluginHandle, :bt_self_plugin_handle
+
+  class BTStreamHandle < BTHandle; end
+  typedef BTStreamHandle, :bt_stream_handle
+
+  class BTStreamClassHandle < BTHandle; end
+  typedef BTStreamClassHandle, :bt_stream_class_handle
+
+  class BTTraceHandle < BTHandle; end
+  typedef BTTraceHandle, :bt_trace_handle
+
+  class BTTraceClassHandle < BTHandle; end
+  typedef BTTraceClassHandle, :bt_trace_class_handle
+
+  class BTValueHandle < BTHandle; end
+  typedef BTValueHandle, :bt_value_handle
+
+  # Additional types for type checking
+  class BTValueNullHandle < BTValueHandle; end
+  typedef BTValueNullHandle, :bt_value_null_handle
+
+  class BTValueBoolHandle < BTValueHandle; end
+  typedef BTValueBoolHandle, :bt_value_bool_handle
+
+  class BTValueIntegerHandle < BTValueHandle; end
+  typedef BTValueIntegerHandle, :bt_value_integer_handle
+
+  class BTValueIntegerUnsignedHandle < BTValueIntegerHandle; end
+  typedef BTValueIntegerUnsignedHandle, :bt_value_integer_unsigned_handle
+
+  class BTValueIntegerSignedHandle < BTValueIntegerHandle; end
+  typedef BTValueIntegerSignedHandle, :bt_value_integer_signed_handle
+
+  class BTValueRealHandle < BTValueHandle; end
+  typedef BTValueRealHandle, :bt_value_real_handle
+
+  class BTValueStringHandle < BTValueHandle; end
+  typedef BTValueStringHandle, :bt_value_string_handle
+
+  class BTValueArrayHandle < BTValueHandle; end
+  typedef BTValueArrayHandle, :bt_value_array_handle
+
+  class BTValueMapHandle < BTValueHandle; end
+  typedef BTValueMapHandle, :bt_value_map_handle
+
+  class BTFieldClassBoolHandle < BTFieldClassHandle; end
+  typedef BTFieldClassBoolHandle, :bt_field_class_bool_handle
+
+  class BTFieldBoolHandle < BTFieldHandle; end
+  typedef BTFieldBoolHandle, :bt_field_bool_handle
+
+  class BTFieldClassBitArrayHandle < BTFieldClassHandle; end
+  typedef BTFieldClassBitArrayHandle, :bt_field_class_bit_array_handle
+
+  class BTFieldBitArrayHandle < BTFieldHandle; end
+  typedef BTFieldBitArrayHandle, :bt_field_bit_array_handle
+
+  class BTFieldClassIntegerHandle < BTFieldClassHandle; end
+  typedef BTFieldClassIntegerHandle, :bt_field_class_integer_handle
+
+  class BTFieldIntegerHandle < BTFieldHandle; end
+  typedef BTFieldIntegerHandle, :bt_field_integer_handle
+
+  class BTFieldClassIntegerUnsignedHandle < BTFieldClassIntegerHandle; end
+  typedef BTFieldClassIntegerUnsignedHandle, :bt_field_class_integer_unsigned_handle
+
+  class BTFieldIntegerUnsignedHandle < BTFieldIntegerHandle; end
+  typedef BTFieldIntegerUnsignedHandle, :bt_field_integer_unsigned_handle
+
+  class BTFieldClassIntegerSignedHandle < BTFieldClassIntegerHandle; end
+  typedef BTFieldClassIntegerSignedHandle, :bt_field_class_integer_signed_handle
+
+  class BTFieldIntegerSignedHandle < BTFieldIntegerHandle; end
+  typedef BTFieldIntegerSignedHandle, :bt_field_integer_signed_handle
+
+  class BTFieldClassRealSinglePrecisionHandle < BTFieldClassHandle; end
+  typedef BTFieldClassRealSinglePrecisionHandle,
+         :bt_field_class_real_single_precision_handle
+
+  class BTFieldRealSinglePrecisionHandle < BTFieldHandle; end
+  typedef BTFieldRealSinglePrecisionHandle,
+         :bt_field_real_single_precision_handle
+
+  class BTFieldClassRealDoublePrecisionHandle < BTFieldClassHandle; end
+  typedef BTFieldClassRealDoublePrecisionHandle,
+          :bt_field_class_real_double_precision_handle
+
+  class BTFieldRealDoublePrecisionHandle < BTFieldHandle; end
+  typedef BTFieldRealDoublePrecisionHandle,
+          :bt_field_real_double_precision_handle
+
+  module BTFieldClassEnumerationHandle; end
+  class BTFieldClassEnumerationHandleCls < BTFieldClassIntegerHandle
+    include BTFieldClassEnumerationHandle
+    class << self
+      def to_native(value, context)
+        unless value.nil?
+          p = value.to_ptr
+          raise "invalid type #{p.class}, expected #{BTFieldClassEnumerationHandle}" unless p.kind_of?(BTFieldClassEnumerationHandle)
+          p
+        else
+          nil
+        end
+      end
+    end
+  end
+  typedef BTFieldClassEnumerationHandleCls, :bt_field_class_enumeration_handle
+
+  module BTFieldEnumerationHandle; end
+  class BTFieldEnumerationHandleCls < BTFieldIntegerHandle
+    include BTFieldEnumerationHandle
+    class << self
+      def to_native(value, context)
+        unless value.nil?
+          p = value.to_ptr
+          raise "invalid type #{p.class}, expected #{BTFieldEnumerationHandle}" unless p.kind_of?(BTFieldEnumerationHandle)
+          p
+        else
+          nil
+        end
+      end
+    end
+  end
+  typedef BTFieldEnumerationHandleCls, :bt_field_enumeration_handle
+
+  class BTFieldClassEnumerationUnsignedHandle < BTFieldClassIntegerUnsignedHandle
+    include BTFieldClassEnumerationHandle
+  end
+  typedef BTFieldClassEnumerationUnsignedHandle,
+          :bt_field_class_enumeration_unsigned_handle
+
+  class BTFieldEnumerationUnsignedHandle < BTFieldIntegerUnsignedHandle
+    include BTFieldEnumerationHandle
+  end
+  typedef BTFieldEnumerationUnsignedHandle,
+          :bt_field_enumeration_unsigned_handle
+
+  class BTFieldClassEnumerationSignedHandle < BTFieldClassIntegerSignedHandle
+    include BTFieldClassEnumerationHandle
+  end
+  typedef BTFieldClassEnumerationSignedHandle,
+          :bt_field_class_enumeration_signed_handle
+
+  class BTFieldEnumerationSignedHandle < BTFieldIntegerSignedHandle
+    include BTFieldClassEnumerationHandle
+  end
+  typedef BTFieldEnumerationSignedHandle,
+          :bt_field_enumeration_signed_handle
+
+  class BTFieldClassStringHandle < BTFieldClassHandle; end
+  typedef BTFieldClassStringHandle, :bt_field_class_string_handle
+
+  class BTFieldStringHandle < BTFieldHandle; end
+  typedef BTFieldStringHandle, :bt_field_string_handle
+
+  class BTFieldClassArrayHandle < BTFieldClassHandle; end
+  typedef BTFieldClassArrayHandle, :bt_field_class_array_handle
+
+  class BTFieldArrayHandle < BTFieldHandle; end
+  typedef BTFieldArrayHandle, :bt_field_array_handle
+
+  class BTFieldClassArrayStaticHandle < BTFieldClassArrayHandle; end
+  typedef BTFieldClassArrayStaticHandle, :bt_field_class_array_static_handle
+
+  class BTFieldArrayStaticHandle < BTFieldArrayHandle; end
+  typedef BTFieldArrayStaticHandle, :bt_field_array_static_handle
+
+  class BTFieldClassArrayDynamicHandle < BTFieldClassArrayHandle; end
+  typedef BTFieldClassArrayDynamicHandle, :bt_field_class_array_dynamic_handle
+
+  class BTFieldArrayDynamicHandle < BTFieldArrayHandle; end
+  typedef BTFieldArrayDynamicHandle, :bt_field_array_dynamic_handle
+
+  class BTFieldClassStructureHandle < BTFieldClassHandle; end
+  typedef BTFieldClassStructureHandle, :bt_field_class_structure_handle
+
+  class BTFieldStructureHandle < BTFieldHandle; end
+  typedef BTFieldStructureHandle, :bt_field_structure_handle
+
+  class BTFieldClassOptionHandle < BTFieldClassHandle; end
+  typedef BTFieldClassOptionHandle, :bt_field_class_option_handle
+
+  class BTFieldOptionHandle < BTFieldHandle; end
+  typedef BTFieldOptionHandle, :bt_field_option_handle
+
+  class BTFieldClassOptionWithoutSelectorFieldHandle < BTFieldClassOptionHandle; end
+  typedef BTFieldClassOptionWithoutSelectorFieldHandle,
+          :bt_field_class_option_without_selector_field_handle
+
+  class BTFieldOptionWithoutSelectorFieldHandle < BTFieldOptionHandle; end
+  typedef BTFieldOptionWithoutSelectorFieldHandle,
+          :bt_field_option_without_selector_field_handle
+
+  class BTFieldClassOptionWithSelectorFieldHandle < BTFieldClassOptionHandle; end
+  typedef BTFieldClassOptionWithSelectorFieldHandle,
+          :bt_field_class_option_with_selector_field_handle
+
+  class BTFieldOptionWithSelectorFieldHandle < BTFieldOptionHandle; end
+  typedef BTFieldOptionWithSelectorFieldHandle,
+          :bt_field_option_with_selector_field_handle
+
+  class BTFieldClassOptionWithSelectorFieldBoolHandle <
+        BTFieldClassOptionWithSelectorFieldHandle; end
+  typedef BTFieldClassOptionWithSelectorFieldBoolHandle,
+          :bt_field_class_option_with_selector_field_bool_handle
+
+  class BTFieldOptionWithSelectorFieldBoolHandle <
+        BTFieldOptionWithSelectorFieldHandle; end
+  typedef BTFieldOptionWithSelectorFieldBoolHandle,
+          :bt_field_option_with_selector_field_bool_handle
+
+  class BTFieldClassOptionWithSelectorFieldIntegerUnsignedHandle <
+        BTFieldClassOptionWithSelectorFieldHandle; end
+  typedef BTFieldClassOptionWithSelectorFieldIntegerUnsignedHandle,
+          :bt_field_class_option_with_selector_field_integer_unsigned_handle
+
+  class BTFieldOptionWithSelectorFieldIntegerUnsignedHandle <
+        BTFieldOptionWithSelectorFieldHandle; end
+  typedef BTFieldOptionWithSelectorFieldIntegerUnsignedHandle,
+          :bt_field_option_with_selector_field_integer_unsigned_handle
+
+  class BTFieldClassOptionWithSelectorFieldIntegerSignedHandle <
+        BTFieldClassOptionWithSelectorFieldHandle; end
+  typedef BTFieldClassOptionWithSelectorFieldIntegerSignedHandle,
+          :bt_field_class_option_with_selector_field_integer_signed_handle
+
+  class BTFieldOptionWithSelectorFieldIntegerSignedHandle <
+        BTFieldOptionWithSelectorFieldHandle; end
+  typedef BTFieldOptionWithSelectorFieldIntegerSignedHandle,
+          :bt_field_option_with_selector_field_integer_signed_handle
+
+  class BTFieldClassVariantHandle < BTFieldClassHandle; end
+  typedef BTFieldClassVariantHandle, :bt_field_class_variant_handle
+
+  class BTFieldVariantHandle < BTFieldHandle; end
+  typedef BTFieldVariantHandle, :bt_field_variant_handle
+
+  class BTFieldVariantWithoutSelectorFieldHandle < BTFieldVariantHandle; end
+  typedef BTFieldVariantWithoutSelectorFieldHandle,
+          :bt_field_variant_without_selector_field_handle
+
+  class BTFieldVariantWithSelectorFieldHandle < BTFieldVariantHandle; end
+  typedef BTFieldVariantWithSelectorFieldHandle,
+          :bt_field_variant_with_selector_field_handle
+
+  class BTFieldVariantWithSelectorFieldIntegerUnsignedHandle <
+        BTFieldVariantWithSelectorFieldHandle; end
+  typedef BTFieldVariantWithSelectorFieldIntegerUnsignedHandle,
+          :bt_field_variant_with_selector_field_integer_unsigned_handle
+
+  class BTFieldVariantWithSelectorFieldIntegerSignedHandle <
+        BTFieldVariantWithSelectorFieldHandle; end
+  typedef BTFieldVariantWithSelectorFieldIntegerSignedHandle,
+          :bt_field_variant_with_selector_field_integer_signed_handle
+
+  typedef :int, :bt_bool
+  typedef :uint64, :bt_listener_id
+  typedef :pointer, :bt_object
+
+  class Error < StandardError
+  end
+
+  class BTObject
+    attr_reader :handle
+
+    def initialize(handle)
+      raise "Invalid handle" if !handle
+      @handle = handle
+    end
+
+    def to_ptr
+      @handle
+    end
+
+    def ==(other)
+      @handle == other.handle
+    end
+  end
+
+  class BTSharedObject < BTObject
+    class Releaser
+      def initialize(handle, releaser)
+        @handle = handle
+        @releaser = releaser
+      end
+
+      def call(id)
+        begin
+          Babeltrace2.method(@releaser).call(@handle)
+        rescue Exception => e
+          puts e
+        end
+      end
+    end
+    @get_ref = nil
+    @put_ref = nil
+    def self.inherited(child)
+      child.instance_variable_set(:@get_ref, @get_ref)
+      child.instance_variable_set(:@put_ref, @put_ref)
+    end
+    class << self
+      attr_reader :get_ref
+      attr_reader :put_ref
+    end
+
+    def initialize(handle, retain: false, auto_release: true)
+      super(handle)
+      Babeltrace2.method(self.class.get_ref).call(handle) if retain
+      ObjectSpace.define_finalizer(self, Releaser.new(handle, self.class.put_ref)) if auto_release
+    end
+  end
+
+  class BTUUID < FFI::Struct
+    layout :id, [ :uint8_t, 16 ]
+    def to_s
+      a = self[:id].to_a
+      s = ""
+      s << "%02x" % a[15]
+      s << "%02x" % a[14]
+      s << "%02x" % a[13]
+      s << "%02x" % a[12]
+      s << "-"
+      s << "%02x" % a[11]
+      s << "%02x" % a[10]
+      s << "-"
+      s << "%02x" % a[9]
+      s << "%02x" % a[8]
+      s << "-"
+      s << "%02x" % a[7]
+      s << "%02x" % a[6]
+      s << "-"
+      s << "%02x" % a[5]
+      s << "%02x" % a[4]
+      s << "%02x" % a[3]
+      s << "%02x" % a[2]
+      s << "%02x" % a[1]
+      s << "%02x" % a[0]
+    end
+
+    def self.from_string(uuid)
+      new.from_string(uuid)
+    end
+
+    def from_string(uuid)
+      m = uuid.match(/(\h\h)(\h\h)(\h\h)(\h\h)-(\h\h)(\h\h)-(\h\h)(\h\h)-(\h\h)(\h\h)-(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)(\h\h)/)
+      raise "invalid format" unless m
+      16.times { |i|
+        self[:id][15-i] = m[i+1].to_i(16)
+      }
+      self
+    end
+  end
+  typedef BTUUID.by_ref, :bt_uuid
+
+  BTPropertyAvailability = enum :bt_property_availability,
+    [ :BT_PROPERTY_AVAILABILITY_NOT_AVAILABLE, 0,
+      :BT_PROPERTY_AVAILABILITY_AVAILABLE, 1 ]
+
+  typedef :pointer, :bt_message_array_const
+
+  BT_TRUE = 1
+  BT_FALSE = 0
+  BT_SLEEP_TIME = 0.1
+
+  @@callbacks = Hash.new { |h, k| h[k] = {} }
+  def self._callbacks
+    @@callbacks
+  end
+end