babeltrace2 0.1.0

data/lib/babeltrace2/graph/port.rb

@@ -0,0 +1,124 @@
+module Babeltrace2
+
+  BT_PORT_TYPE_INPUT = 1 << 0
+  BT_PORT_TYPE_OUTPUT = 1 << 1
+  BTPortType = enum :bt_port_type,
+    [ :BT_PORT_TYPE_INPUT,
+       BT_PORT_TYPE_INPUT,
+      :BT_PORT_TYPE_OUTPUT,
+       BT_PORT_TYPE_OUTPUT ]
+
+  attach_function :bt_port_get_type,
+                  [ :bt_port_handle ],
+                  :bt_port_type
+
+  attach_function :bt_port_borrow_connection_const,
+                  [ :bt_port_handle ],
+                  :bt_connection_handle
+
+  attach_function :bt_port_borrow_component_const,
+                  [ :bt_port_handle ],
+                  :bt_component_handle
+
+  attach_function :bt_port_get_name,
+                  [ :bt_port_handle ],
+                  :string
+
+  attach_function :bt_port_is_connected,
+                  [ :bt_port_handle ],
+                  :bt_bool
+
+  attach_function :bt_port_get_ref,
+                  [ :bt_port_handle ],
+                  :void
+
+  attach_function :bt_port_put_ref,
+                  [ :bt_port_handle ],
+                  :void
+
+  class BTPort < BTSharedObject
+    Type = BTPortType
+    @get_ref = :bt_port_get_ref
+    @put_ref = :bt_port_put_ref
+
+    def self.from_handle(handle, retain: true, auto_release: true)
+      case Babeltrace2.bt_port_get_type(handle)
+      when :BT_PORT_TYPE_INPUT
+        handle = BTPortInputHandle.new(handle)
+        BTPortInput
+      when :BT_PORT_TYPE_OUTPUT
+        handle = BTPortOuputHandle.new(handle)
+        BTPortOutput
+      else
+        raise Error.new("Unknown port type")
+      end.new(handle, retain: retain, auto_release: auto_release)
+    end
+
+    def get_type
+      Babeltrace2.bt_port_get_type(@handle)
+    end
+    alias type get_type
+
+    def is_input
+      get_type == :BT_PORT_TYPE_INPUT
+    end
+    alias input? is_input
+
+    def is_output
+      get_type == :BT_PORT_TYPE_OUTPUT
+    end
+    alias output? is_output
+
+    def get_connection
+      handle = Babeltrace2.bt_port_borrow_connection_const(@handle)
+      return nil if handle.null?
+      BTConnection.new(handle, retain: true, auto_release: true)
+    end
+    alias connection get_connection
+
+    def get_component
+      handle = Babeltrace2.bt_port_borrow_component_const(@handle)
+      BTComponent.from_handle(handle)
+    end
+    alias component get_component
+
+    def get_name
+      Babeltrace2.bt_port_get_name(@handle)
+    end
+    alias name get_name
+
+    def is_connected
+      Babeltrace2.bt_port_is_connected(@handle) != BT_FALSE
+    end
+    alias connected? is_connected
+  end
+
+  attach_function :bt_port_input_get_ref,
+                  [ :bt_port_input_handle ],
+                  :void
+
+  attach_function :bt_port_input_put_ref,
+                  [ :bt_port_input_handle ],
+                  :void
+
+  class BTPort::Input < BTPort
+    @get_ref = :bt_port_input_get_ref
+    @put_ref = :bt_port_input_put_ref
+  end
+  BTPortInput = BTPort::Input
+
+  attach_function :bt_port_output_get_ref,
+                  [ :bt_port_output_handle ],
+                  :void
+
+  attach_function :bt_port_output_put_ref,
+                  [ :bt_port_output_handle ],
+                  :void
+
+  class BTPort::Output < BTPort
+    @get_ref = :bt_port_output_get_ref
+    @put_ref = :bt_port_output_put_ref
+  end
+  BTPortOutput = BTPort::Output
+
+end

data/lib/babeltrace2/graph/private-query-executor.rb

@@ -0,0 +1,4 @@
+module Babeltrace2
+  class BTPrivateQueryExecutor < BTQueryExecutor
+  end
+end

data/lib/babeltrace2/graph/query-executor.rb

@@ -0,0 +1,142 @@
+module Babeltrace2
+
+  attach_function :bt_query_executor_create,
+                  [ :bt_component_class_handle,
+                    :string, :bt_value_handle ],
+                  :bt_query_executor_handle
+
+  attach_function :bt_query_executor_create_with_method_data,
+                  [ :bt_component_class_handle,
+                    :string, :bt_value_handle, :pointer ],
+                  :bt_query_executor_handle
+
+  BT_QUERY_EXECUTOR_QUERY_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_QUERY_EXECUTOR_QUERY_STATUS_UNKNOWN_OBJECT = BT_FUNC_STATUS_UNKNOWN_OBJECT
+  BT_QUERY_EXECUTOR_QUERY_STATUS_AGAIN = BT_FUNC_STATUS_AGAIN
+  BT_QUERY_EXECUTOR_QUERY_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BT_QUERY_EXECUTOR_QUERY_STATUS_ERROR = BT_FUNC_STATUS_ERROR
+  BTQueryExecutorQueryStatus = enum :bt_query_executor_query_status,
+    [ :BT_QUERY_EXECUTOR_QUERY_STATUS_OK,
+       BT_QUERY_EXECUTOR_QUERY_STATUS_OK,
+      :BT_QUERY_EXECUTOR_QUERY_STATUS_UNKNOWN_OBJECT,
+       BT_QUERY_EXECUTOR_QUERY_STATUS_UNKNOWN_OBJECT,
+      :BT_QUERY_EXECUTOR_QUERY_STATUS_AGAIN,
+       BT_QUERY_EXECUTOR_QUERY_STATUS_AGAIN,
+      :BT_QUERY_EXECUTOR_QUERY_STATUS_MEMORY_ERROR,
+       BT_QUERY_EXECUTOR_QUERY_STATUS_MEMORY_ERROR,
+      :BT_QUERY_EXECUTOR_QUERY_STATUS_ERROR,
+       BT_QUERY_EXECUTOR_QUERY_STATUS_ERROR ]
+
+  attach_function :bt_query_executor_query,
+                  [ :bt_query_executor_handle,
+                    :pointer ],
+                  :bt_query_executor_query_status
+
+  BT_QUERY_EXECUTOR_SET_LOGGING_LEVEL_STATUS_OK = BT_FUNC_STATUS_OK
+  BTQueryExecutorSetLoggingLevelStatus = enum :bt_query_executor_set_logging_level_status,
+    [ :BT_QUERY_EXECUTOR_SET_LOGGING_LEVEL_STATUS_OK,
+       BT_QUERY_EXECUTOR_SET_LOGGING_LEVEL_STATUS_OK ]
+
+  attach_function :bt_query_executor_set_logging_level,
+                  [ :bt_query_executor_handle,
+                    :bt_logging_level ],
+                  :bt_query_executor_set_logging_level_status
+
+  attach_function :bt_query_executor_get_logging_level,
+                  [ :bt_query_executor_handle ],
+                  :bt_logging_level
+
+  BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BTQueryExecutorAddInterrupterStatus = enum :bt_query_executor_add_interrupter_status,
+    [ :BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_OK,
+       BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_OK,
+      :BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_MEMORY_ERROR,
+       BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_MEMORY_ERROR ]
+
+  attach_function :bt_query_executor_add_interrupter,
+                  [ :bt_query_executor_handle,
+                    :bt_interrupter_handle ],
+                  :bt_query_executor_add_interrupter_status
+
+  attach_function :bt_query_executor_borrow_default_interrupter,
+                  [ :bt_query_executor_handle ],
+                  :bt_interrupter_handle
+
+  attach_function :bt_query_executor_is_interrupted,
+                  [ :bt_query_executor_handle ],
+                  :bt_bool
+
+  attach_function :bt_query_executor_get_ref,
+                  [ :bt_query_executor_handle ],
+                  :void
+
+  attach_function :bt_query_executor_put_ref,
+                  [ :bt_query_executor_handle ],
+                  :void
+
+  class BTQueryExecutor < BTSharedObject
+    QueryStatus = BTQueryExecutorQueryStatus
+    SetLoggingLevelStatus = BTQueryExecutorSetLoggingLevelStatus
+    AddInterrupterStatus = BTQueryExecutorAddInterrupterStatus
+    @get_ref = :bt_query_executor_get_ref
+    @put_ref = :bt_query_executor_put_ref
+
+    def initialize(handle = nil, retain: true, auto_release: true,
+                   component_class: nil, object_name: nil, params: nil, method_data: nil)
+      if handle
+        super(handle, retain: retain, auto_release: auto_release)
+      else
+        handle = Babeltrace2.bt_query_executor_create_with_method_data(
+                   component_class, object_name, BTValue.from_value(params), method_data)
+        raise Babeltrace2.process_error if handle.null?
+        super(handle)
+      end
+    end
+
+    def query
+      ptr = FFI::MemoryPointer.new(:pointer)
+      while ((res = Babeltrace2.bt_query_executor_query(@handle, ptr)) == :BT_QUERY_EXECUTOR_QUERY_STATUS_AGAIN)
+        raise "interrupted by user" if interrupted?
+        sleep BT_SLEEP_TIME
+      end
+      raise Babeltrace2.process_error(res) if res != :BT_QUERY_EXECUTOR_QUERY_STATUS_OK
+      BTValue.from_handle(BTValueHandle.new(ptr.read_pointer), retain: false)
+    end
+
+    def set_logging_level(logging_level)
+      res = Babeltrace2.bt_query_executor_set_logging_level(@handle, logging_level)
+      raise Babeltrace2.process_error(res) if res != :BT_QUERY_EXECUTOR_SET_LOGGING_LEVEL_STATUS_OK
+      self
+    end
+
+    def logging_level=(logging_level)
+      res = Babeltrace2.bt_query_executor_set_logging_level(@handle, logging_level)
+      raise Babeltrace2.process_error(res) if res != :BT_QUERY_EXECUTOR_SET_LOGGING_LEVEL_STATUS_OK
+      return logging_level
+    end
+
+    def get_logging_level
+      Babeltrace2.bt_query_executor_get_logging_level(@handle)
+    end
+    alias logging_level get_logging_level
+
+    def add_interrupter(interrupter)
+      res = Babeltrace2.bt_query_executor_add_interrupter(@handle, interrupter)
+      raise Babeltrace2.process_error(res) if res != :BT_QUERY_EXECUTOR_ADD_INTERRUPTER_STATUS_OK
+      self
+    end
+
+    def get_default_interrupter
+      handle = Babeltrace2.bt_query_executor_borrow_default_interrupter(@handle)
+      BTInterrupter.new(handle, retain: true)
+    end
+    alias default_interrupter get_default_interrupter
+
+    def is_interrupted
+      Babeltrace2.bt_query_executor_is_interrupted(@handle) != BT_FALSE
+    end
+    alias interrupted? is_interrupted
+  end
+  
+end

data/lib/babeltrace2/graph/self-component-class.rb

@@ -0,0 +1,37 @@
+module Babeltrace2
+  module BTSelfComponent
+    module Class
+      def self.from_handle(handle, retain: true, auto_release: true)
+        case Babeltrace2.bt_component_class_get_type(handle)
+        when :BT_COMPONENT_CLASS_TYPE_SOURCE
+          handle = BTSelfComponentClassSourceHandle.new(handle)
+          BTSelfComponentClassSource
+        when :BT_COMPONENT_CLASS_TYPE_FILTER
+          handle = BTSelfComponentClassFilterHandle.new(handle)
+          BTSelfComponentClassFilter
+        when :BT_COMPONENT_CLASS_TYPE_SINK
+          handle = BTSelfComponentClassSinkHandle.new(handle)
+          BTSelfComponentClassSink
+        else
+          raise Error.new("Unknown component class type")
+        end.new(handle, retain: retain, auto_release: auto_release)
+      end
+    end
+  end
+  BTSelfComponentClass = BTSelfComponent::Class
+
+  class BTSelfComponent::Class::Source < BTComponentClassSource
+    include BTSelfComponent::Class
+  end
+  BTSelfComponentClassSource = BTSelfComponent::Class::Source
+
+  class BTSelfComponent::Class::Filter < BTComponentClassFilter
+    include BTSelfComponent::Class
+  end
+  BTSelfComponentClassFilter = BTSelfComponent::Class::Filter
+
+  class BTSelfComponent::Class::Sink < BTComponentClassSink
+    include BTSelfComponent::Class
+  end
+  BTSelfComponentClassSink = BTSelfComponent::Class::Sink
+end

data/lib/babeltrace2/graph/self-component-port.rb

@@ -0,0 +1,35 @@
+module Babeltrace2
+
+  attach_function :bt_self_component_port_borrow_component,
+                  [ :bt_self_component_port_handle ],
+                  :bt_self_component_handle
+
+  attach_function :bt_self_component_port_get_data,
+                  [ :bt_self_component_port_handle ],
+                  :pointer
+
+  module BTSelfComponent
+    module Port
+      def get_component
+        handle = Babeltrace2.bt_self_component_port_borrow_component(@handle)
+        BTSelfComponent.from_handle(handle)
+      end
+      alias component get_component
+
+      def get_data
+        Babeltrace2.bt_self_component_port_get_data(@handle)
+      end
+      alias data get_data
+    end
+  end
+
+  class BTSelfComponent::Port::Input < BTPort::Input
+    include BTSelfComponent::Port
+  end
+  BTSelfComponentPortInput = BTSelfComponent::Port::Input
+
+  class BTSelfComponent::Port::Output < BTPort::Output
+    include BTSelfComponent::Port
+  end
+  BTSelfComponentPortOutput = BTSelfComponent::Port::Output
+end

data/lib/babeltrace2/graph/self-component.rb

@@ -0,0 +1,264 @@
+module Babeltrace2
+
+  BT_SELF_COMPONENT_ADD_PORT_STATUS_OK = BT_FUNC_STATUS_OK
+  BT_SELF_COMPONENT_ADD_PORT_STATUS_MEMORY_ERROR = BT_FUNC_STATUS_MEMORY_ERROR
+  BT_SELF_COMPONENT_ADD_PORT_STATUS_ERROR = BT_FUNC_STATUS_ERROR
+  BTSelfComponentAddPortStatus = enum :bt_self_component_add_port_status,
+    [ :BT_SELF_COMPONENT_ADD_PORT_STATUS_OK,
+       BT_SELF_COMPONENT_ADD_PORT_STATUS_OK,
+      :BT_SELF_COMPONENT_ADD_PORT_STATUS_MEMORY_ERROR,
+       BT_SELF_COMPONENT_ADD_PORT_STATUS_MEMORY_ERROR,
+      :BT_SELF_COMPONENT_ADD_PORT_STATUS_ERROR,
+       BT_SELF_COMPONENT_ADD_PORT_STATUS_ERROR ]
+
+  attach_function :bt_self_component_get_data,
+                  [ :bt_self_component_handle ],
+                  :pointer
+
+  attach_function :bt_self_component_set_data,
+                  [ :bt_self_component_handle,
+                    :pointer ],
+                  :void
+
+  attach_function :bt_self_component_get_graph_mip_version,
+                  [ :bt_self_component_handle ],
+                  :uint64
+
+  module BTSelfComponent
+    AddPortStatus = BTSelfComponentAddPortStatus
+
+    def self.from_handle(handle, retain: true, auto_release: true)
+      case Babeltrace2.bt_component_get_class_type(handle)
+      when :BT_COMPONENT_CLASS_TYPE_SOURCE
+        handle = BTSelfComponentSourceHandle.new(handle)
+        BTSelfComponentSource
+      when :BT_COMPONENT_CLASS_TYPE_FILTER
+        handle = BTSelfComponentFilterHandle.new(handle)
+        BTSelfComponentFilter
+      when :BT_COMPONENT_CLASS_TYPE_SINK
+        handle = BTSelfComponentSinkHandle.new(handle)
+        BTSelfComponentSink
+      else
+        raise Error.new("Unknown component class type")
+      end.new(handle, retain: retain, auto_release: auto_release)
+    end
+
+    def set_data(user_data)
+      Babeltrace2.bt_self_component_set_data(@handle, user_data)
+      self
+    end
+
+    def data=(user_data)
+      set_data(user_data)
+      user_data
+    end
+
+    def get_data
+      Babeltrace2.bt_self_component_get_data(@handle)
+    end
+    alias data get_data
+
+    def get_graph_mip_version
+      Babeltrace2.bt_self_component_get_graph_mip_version(@handle)
+    end
+    alias graph_mip_version get_graph_mip_version
+
+    def create_trace_class
+      BTTraceClass.new(self_component: @handle)
+    end
+
+    def create_clock_class
+      BTClockClass.new(self_component: @handle)
+    end
+  end
+
+  attach_function :bt_self_component_source_add_output_port,
+                  [ :bt_self_component_source_handle,
+                    :string, :pointer,
+                    :pointer ],
+                  :bt_self_component_add_port_status
+
+  attach_function :bt_self_component_source_borrow_output_port_by_index,
+                  [ :bt_self_component_source_handle,
+                    :uint64 ],
+                  :bt_self_component_port_output_handle
+
+  attach_function :bt_self_component_source_borrow_output_port_by_name,
+                  [ :bt_self_component_source_handle,
+                    :string ],
+                  :bt_self_component_port_output_handle
+
+  class BTSelfComponent::Source < BTComponent::Source
+    include BTSelfComponent
+    class Configuration < BTObject
+    end
+
+    def add_output_port(name, user_data: nil)
+      ptr = FFI::MemoryPointer.new(:pointer)
+      res = Babeltrace2.bt_self_component_source_add_output_port(@handle, name, user_data, ptr)
+      raise Babeltrace2.process_error(res) if res != :BT_SELF_COMPONENT_ADD_PORT_STATUS_OK
+      BTSelfComponentPortOutput.new(BTSelfComponentPortOutputHandle.new(ptr.read_pointer),
+                                    retain: false, auto_release: false)
+    end
+
+    def get_output_port_by_index(index)
+      count = get_output_port_count
+      index += count if index < 0
+      return nil if index >= count || index < 0
+      handle = Babeltrace2.bt_self_component_source_borrow_output_port_by_index(@handle, index)
+      BTSelfComponentPortOutput.new(handle, retain: false, auto_release: false)
+    end
+
+    def get_output_port_by_name(name)
+      handle = Babeltrace2.bt_self_component_source_borrow_output_port_by_name(@handle, name)
+      return nil if handle.null?
+      BTSelfComponentPortOutput.new(handle, retain: false, auto_release: false)
+    end
+  end
+  BTSelfComponentSource = BTSelfComponent::Source
+  BTSelfComponentSourceConfiguration = BTSelfComponent::Source::Configuration
+
+  attach_function :bt_self_component_filter_add_input_port,
+                  [ :bt_self_component_filter_handle,
+                    :string, :pointer,
+                    :pointer ],
+                  :bt_self_component_add_port_status
+
+  attach_function :bt_self_component_filter_add_output_port,
+                  [ :bt_self_component_filter_handle,
+                    :string, :pointer,
+                    :pointer ],
+                  :bt_self_component_add_port_status
+
+  attach_function :bt_self_component_filter_borrow_output_port_by_index,
+                  [ :bt_self_component_filter_handle,
+                    :uint64 ],
+                  :bt_self_component_port_output_handle
+
+  attach_function :bt_self_component_filter_borrow_output_port_by_name,
+                  [ :bt_self_component_filter_handle,
+                    :string ],
+                  :bt_self_component_port_output_handle
+
+  attach_function :bt_self_component_filter_borrow_input_port_by_index,
+                  [ :bt_self_component_filter_handle,
+                    :uint64 ],
+                  :bt_self_component_port_input_handle
+
+  attach_function :bt_self_component_filter_borrow_input_port_by_name,
+                  [ :bt_self_component_filter_handle,
+                    :string ],
+                  :bt_self_component_port_input_handle
+
+  class BTSelfComponent::Filter < BTComponent::Filter
+    include BTSelfComponent
+    class Configuration < BTObject
+    end
+
+    def add_output_port(name, user_data: nil)
+      ptr = FFI::MemoryPointer.new(:pointer)
+      res = Babeltrace2.bt_self_component_filter_add_output_port(@handle, name, user_data, ptr)
+      raise Babeltrace2.process_error(res) if res != :BT_SELF_COMPONENT_ADD_PORT_STATUS_OK
+      BTSelfComponentPortOutput.new(BTSelfComponentPortOutputHandle.new(ptr.read_pointer),
+                                    retain: false, auto_release: false)
+    end
+
+    def add_input_port(name, user_data: nil)
+      ptr = FFI::MemoryPointer.new(:pointer)
+      res = Babeltrace2.bt_self_component_filter_add_input_port(@handle, name, user_data, ptr)
+      raise Babeltrace2.process_error(res) if res != :BT_SELF_COMPONENT_ADD_PORT_STATUS_OK
+      BTSelfComponentPortInput.new(BTSelfComponentPortInputHandle.new(ptr.read_pointer),
+                                   retain: false, auto_release: false)
+    end
+
+    def get_output_port_by_index(index)
+      count = get_output_port_count
+      index += count if index < 0
+      return nil if index >= count || index < 0
+      handle = Babeltrace2.bt_self_component_filter_borrow_output_port_by_index(@handle, index)
+      BTSelfComponentPortOutput.new(handle, retain: false, auto_release: false)
+    end
+
+    def get_output_port_by_name(name)
+      handle = Babeltrace2.bt_self_component_filter_borrow_output_port_by_name(@handle, name)
+      return nil if handle.null?
+      BTSelfComponentPortOutput.new(handle, retain: false, auto_release: false)
+    end
+
+    def get_input_port_by_index(index)
+      count = get_input_port_count
+      index += count if index < 0
+      return nil if index >= count || index < 0
+      handle = Babeltrace2.bt_self_component_filter_borrow_input_port_by_index(@handle, index)
+      BTSelfComponentPortInput.new(handle, retain: false, auto_release: false)
+    end
+
+    def get_input_port_by_name(name)
+      handle = Babeltrace2.bt_self_component_filter_borrow_input_port_by_name(@handle, name)
+      return nil if handle.null?
+      BTSelfComponentPortInput.new(handle, retain: false, auto_release: false)
+    end
+  end
+  BTSelfComponentFilter = BTSelfComponent::Filter
+  BTSelfComponentFilterConfiguration = BTSelfComponent::Filter::Configuration
+
+  attach_function :bt_self_component_sink_add_input_port,
+                  [ :bt_self_component_sink_handle,
+                    :string, :pointer,
+                    :pointer ],
+                  :bt_self_component_add_port_status
+
+  attach_function :bt_self_component_sink_borrow_input_port_by_index,
+                  [ :bt_self_component_sink_handle,
+                    :uint64 ],
+                  :bt_self_component_port_input_handle
+
+  attach_function :bt_self_component_sink_borrow_input_port_by_name,
+                  [ :bt_self_component_sink_handle,
+                    :string ],
+                  :bt_self_component_port_input_handle
+
+  attach_function :bt_self_component_sink_is_interrupted,
+                  [ :bt_self_component_sink_handle ],
+                  :bt_bool
+
+  class BTSelfComponent::Sink < BTComponent::Sink
+    include BTSelfComponent
+    class Configuration < BTObject
+    end
+
+    def add_input_port(name, user_data: nil)
+      ptr = FFI::MemoryPointer.new(:pointer)
+      res = Babeltrace2.bt_self_component_sink_add_input_port(@handle, name, user_data, ptr)
+      raise Babeltrace2.process_error(res) if res != :BT_SELF_COMPONENT_ADD_PORT_STATUS_OK
+      BTSelfComponentPortInput.new(BTSelfComponentPortInputHandle.new(ptr.read_pointer),
+                                   retain: false, auto_release: false)
+    end
+
+    def get_input_port_by_index(index)
+      count = get_input_port_count
+      index += count if index < 0
+      return nil if index >= count || index < 0
+      handle = Babeltrace2.bt_self_component_sink_borrow_input_port_by_index(@handle, index)
+      BTSelfComponentPortInput.new(handle, retain: false, auto_release: false)
+    end
+
+    def get_input_port_by_name(name)
+      handle = Babeltrace2.bt_self_component_sink_borrow_input_port_by_name(@handle, name)
+      return nil if handle.null?
+      BTSelfComponentPortInput.new(handle, retain: false, auto_release: false)
+    end
+
+    def is_interrupted
+      Babeltrace2.bt_self_component_sink_is_interrupted(@handle) != BT_FALSE
+    end
+    alias interrupted? is_interrupted
+
+    def create_message_iterator(port)
+      BTMessageIterator.create_from_sink_component(self, port)
+    end
+  end
+  BTSelfComponentSink = BTSelfComponent::Sink
+  BTSelfComponentSinkConfiguration = BTSelfComponent::Sink::Configuration
+
+end