module BT2

# File lib/babeltrace2/types.rb, line 664
def self._callbacks
  @@callbacks
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 242
def self._wrap_component_class_filter_input_port_connected_method(handle, method)
  _wrap_component_class_port_connected_method(
    BTSelfComponentFilter, BTSelfComponentPortInput, BTPortOutput,
    :input_port_connected_method, handle, method)
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 254
def self._wrap_component_class_filter_output_port_connected_method(handle, method)
  _wrap_component_class_port_connected_method(
    BTSelfComponentFilter, BTSelfComponentPortOutput, BTPortInput,
    :output_port_connected_method, handle, method)
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 51
def self._wrap_component_class_finalize_method(component_class, handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_component|
    begin
      method.call(component_class.new(self_component,
                                      retain: false, auto_release: false))
    rescue Exception => e
      puts e
    end
  }
  @@callbacks[id][:finalize_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 89
def self._wrap_component_class_get_supported_mip_versions_method(component_class_class, handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_component_class, params, initialize_method_data, logging_level, supported_versions|
    begin
      method.call(component_class_class.new(self_component_class,
                    retain: false, auto_release: false),
                  BTValue.from_handle(params, retain: false, auto_release: false),
                  initialize_method_data, logging_level,
                  BTIntergerRangeSetUnsigned.new(supported_versions,
                    retain: false, auto_release: false))
      :BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_component_class)
      :BT_COMPONENT_CLASS_GET_SUPPORTED_MIP_VERSIONS_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:get_supported_mip_versions_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 171
def self._wrap_component_class_initialize_method(component_class, component_configuration_class, handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_component, configuration, params, initialize_method_data|
    begin
      method.call(component_class.new(self_component,
                    retain: false, auto_release: false),
                  component_configuration_class.new(configuration),
                  BTValue.from_handle(params, retain: false, auto_release: false),
                  initialize_method_data)
      :BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_component)
      :BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:initialize_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 208
def self._wrap_component_class_port_connected_method(
           self_component_class, self_component_port_class, port_class,
           category, handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_component, self_port, other_port|
    begin
      method.call(self_component_class.new(self_component,
                    retain: false, auto_release: false),
                  self_component_port_class.new(self_port,
                    retain: false, auto_release: false),
                  port_class.new(other_port,
                    retain: false, auto_release: false))
      :BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_component)
      :BT_COMPONENT_CLASS_PORT_CONNECTED_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][category] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 290
def self._wrap_component_class_query_method(component_class_class, handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_component_class, query_executor, object_name, params, method_data, result|
    begin
      rvalue = method.call(component_class_class.new(self_component_class,
                              retain: false, auto_release: false),
                            BTPrivateQueryExecutor.new(query_executor,
                              retain: false, auto_release: false),
                            object_name, BTValue.from_handle(params,
                              retain: false, auto_release: false), method_data)
      unless rvalue.nil?
        rvalue = BTValue.from_value(rvalue)
        bt_value_get_ref(rvalue.handle)
        result.write_pointer(rvalue.handle)
        :BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_OK
      else
        :BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_UNKNOWN_OBJECT
      end
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_component_class)
      :BT_COMPONENT_CLASS_QUERY_METHOD_STATUS_ERROR
    end      
  }
  @@callbacks[id][:query_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 24
def self._wrap_component_class_sink_consume_method(method)
  lambda { |self_component|
    begin
      method.call(BTSelfComponentSink.new(self_component,
                                          retain: false, auto_release: false))
      :BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK
    rescue StopIteration
      :BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_END
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_component)
      :BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR
    end
  }
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 125
def self._wrap_component_class_sink_graph_is_configured_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_component|
    begin
      method.call(BTSelfComponentSink.new(self_component,
                    retain: false, auto_release: false))
      :BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_component)
      :BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:graph_is_configured_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 266
def self._wrap_component_class_sink_input_port_connected_method(handle, method)
  _wrap_component_class_port_connected_method(
    BTSelfComponentSink, BTSelfComponentPortInput, BTPortOutput,
    :input_port_connected_method, handle, method)
end

# File lib/babeltrace2/graph/component-class-dev.rb, line 230
def self._wrap_component_class_source_output_port_connected_method(handle, method)
  _wrap_component_class_port_connected_method(
    BTSelfComponentSource, BTSelfComponentPortOutput, BTPortInput,
    :output_port_connected_method, handle, method)
end

# File lib/babeltrace2/graph/graph.rb, line 236
def self._wrap_graph_component_port_added_listener_func(
           component_class, port_class, category, handle, method)
  id = handle.to_i
  method_wrapper = lambda { |component, port, user_data|
    begin
      method.call(component_class.new(component, retain: false, auto_release: false),
                  port_class.new(port, retain: false, auto_release: false),
                  user_data)
      :BT_GRAPH_LISTENER_FUNC_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: component)
      :BT_GRAPH_LISTENER_FUNC_STATUS_ERROR
    end
  }
  arr = @@callbacks[id][category]
  if arr.nil?
    arr = []
    @@callbacks[id][category] = arr
  end
  arr.push method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/graph.rb, line 259
def self._wrap_graph_filter_component_input_port_added_listener_func(handle, method)
  _wrap_graph_component_port_added_listener_func(
    BTComponentFilter, BTPortInput, :filter_component_input_port_added_listener_funcs,
    handle, method)
end

# File lib/babeltrace2/graph/graph.rb, line 310
def self._wrap_graph_filter_component_output_port_added_listener_func(handle, method)
  _wrap_graph_component_port_added_listener_func(
    BTComponentFilter, BTPortOutput, :filter_component_output_port_added_listener_funcs,
    handle, method)
end

# File lib/babeltrace2/graph/graph.rb, line 111
def self._wrap_graph_simple_sink_component_consume_func(method)
  lambda { |message_iterator, user_data|
    begin
      method.call(BTMessageIterator.new(message_iterator,
                    retain: false, auto_release: false), user_data)
      :BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_OK
    rescue StopIteration
      :BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_END
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: message_iterator)
      :BT_GRAPH_SIMPLE_SINK_COMPONENT_CONSUME_FUNC_STATUS_ERROR
    end
  }
end

# File lib/babeltrace2/graph/graph.rb, line 76
def self._wrap_graph_simple_sink_component_initialize_func(method)
  lambda { |message_iterator, user_data|
    begin
      method.call(BTMessageIterator.new(message_iterator,
                    retain: false, auto_release: false), user_data)
      :BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: message_iterator)
      :BT_GRAPH_SIMPLE_SINK_COMPONENT_INITIALIZE_FUNC_STATUS_ERROR
    end
  }
end

# File lib/babeltrace2/graph/graph.rb, line 276
def self._wrap_graph_sink_component_input_port_added_listener_func(handle, method)
  _wrap_graph_component_port_added_listener_func(
    BTComponentSink, BTPortInput, :sink_component_input_port_added_listener_funcs,
    handle, method)
end

# File lib/babeltrace2/graph/graph.rb, line 293
def self._wrap_graph_source_component_output_port_added_listener_func(handle, method)
  _wrap_graph_component_port_added_listener_func(
    BTComponentSource, BTPortOutput, :source_component_output_port_added_listener_funcs,
    handle, method)
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 23
def self._wrap_message_iterator_class_can_seek_beginning_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_message_iterator, can_seek_beginning|
    begin
      csb = method.call(BTSelfMessageIterator.new(self_message_iterator,
                          retain: false, auto_release: false))
      can_seek_beginning.write_int(csb ? BT_TRUE : BT_FALSE)
      :BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_message_iterator)
      :BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_BEGINNING_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:can_seek_beginning_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 60
def self._wrap_message_iterator_class_can_seek_ns_from_origin_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_message_iterator, ns_from_origin, can_seek_beginning|
    begin
      csb = method.call(BTSelfMessageIterator.new(self_message_iterator,
                          retain: false, auto_release: false), ns_from_origin)
      can_seek_beginning.write_int(csb ? BT_TRUE : BT_FALSE)
      :BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_message_iterator)
      :BT_MESSAGE_ITERATOR_CLASS_CAN_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:can_seek_ns_from_origin_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 81
def self._wrap_message_iterator_class_finalize_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_message_iterator|
    begin
      method.call(BTSelfMessageIterator.new(self_message_iterator,
                          retain: false, auto_release: false))
    rescue Exception => e
      puts e
    end
  }
  @@callbacks[id][:finalize_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 113
def self._wrap_message_iterator_class_initialize_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_message_iterator, configuration, port|
    begin
      method.call(BTSelfMessageIterator.new(self_message_iterator,
                    retain: false, auto_release: false),
                  BTSelfMessageIteratorConfiguration.new(configuration),
                  BTSelfComponentPortOutput.new(port,
                    retain: false, auto_release: false))
      :BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_message_iterator)
      :BT_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:initialize_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 156
def self._wrap_message_iterator_class_next_method(method)
  lambda { |self_message_iterator, messages, capacity, count|
    begin
      mess = method.call(BTSelfMessageIterator.new(self_message_iterator,
                           retain: false, auto_release: false),
                         capacity)
      if mess.size <= capacity
        mess.each { |m| bt_message_get_ref(m.handle) }
        messages.write_array_of_pointer(mess.collect(&:handle))
        count.write_uint64(mess.size)
        :BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK
      else
        puts "Too many messages for capacity"
        :BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR
      end
    rescue StopIteration
      :BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_END
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_message_iterator)
      :BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR
    end
  }
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 199
def self._wrap_message_iterator_class_seek_beginning_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_message_iterator|
    begin
      method.call(BTSelfMessageIterator.new(self_message_iterator,
                    retain: false, auto_release: false))
      :BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_message_iterator)
      :BT_MESSAGE_ITERATOR_CLASS_SEEK_BEGINNING_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:seek_beginning_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/graph/message-iterator-class.rb, line 235
def self._wrap_message_iterator_class_seek_ns_from_origin_method(handle, method)
  id = handle.to_i
  method_wrapper = lambda { |self_message_iterator, ns_from_origin|
    begin
      method.call(BTSelfMessageIterator.new(self_message_iterator,
        retain: false, auto_release: false), ns_from_origin)
      :BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_OK
    rescue Exception => e
      Babeltrace2.stack_ruby_error(e, source: self_message_iterator)
      :BT_MESSAGE_ITERATOR_CLASS_SEEK_NS_FROM_ORIGIN_METHOD_STATUS_ERROR
    end
  }
  @@callbacks[id][:seek_ns_from_origin_method] = method_wrapper
  method_wrapper
end

# File lib/babeltrace2/trace-ir/trace-class.rb, line 51
def self._wrap_trace_class_destruction_listener_func(method)
  method_wrapper = lambda { |trace_class, user_data|
    begin
      method.call(BTTraceClass.new(trace_class,
                    retain: false, auto_release: false), user_data)
    rescue Exception => e
      puts e
    end
  }
  method_wrapper
end

# File lib/babeltrace2/trace-ir/trace.rb, line 103
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

# File lib/babeltrace2/plugin/plugin-dev.rb, line 321
def self.load_plugin_file(path)
  return [] unless File.exist?(path)
  hash = Digest::SHA256.file(path).to_s
  return @@native_plugins[hash] if @@native_plugins.include?(hash)
  @@user_plugins = []
  str = ""
  str << "module Mod#{hash}; class << self; def register_user_plugin(plugin); Babeltrace2.register_user_plugin(plugin); end; alias register_plugin register_user_plugin; alias register register_user_plugin; end; "
  str << File.read(path) << "; end"
  eval(str, nil, path)
  @@user_plugins.each { |p|
    p.path = path unless p.path
  }
  @@native_plugins[hash] = @@user_plugins
end

# File lib/babeltrace2/error-reporting.rb, line 424
def self.process_error(code = :BT_FUNC_STATUS_MEMORY_ERROR)
  err = BTCurrentThread.take_error
  if err
    klass, message, backtrace = err.exception_params
    err.release
  else
    klass, message, backtrace = nil, nil, []
  end
  if klass
    klass = eval(klass)
    e = klass.new(message)
  else
    message = "#{code}" unless message
    e = Error.new(message)
  end
  e.set_backtrace(backtrace+caller_locations.collect(&:to_s))
  e
end

# File lib/babeltrace2/plugin/plugin-dev.rb, line 317
def self.register_user_plugin(plugin)
  @@user_plugins.push(plugin)
end

# File lib/babeltrace2/error-reporting.rb, line 374
def self.stack_error(source, message, absolute_path, lineno)
  case source
  when BTSelfComponent, BTSelfComponentHandle
    BTCurrentThread::Error.append_cause_from_component(
      source, message, file_name: absolute_path, line_number: lineno)
  when BTSelfComponentClass, BTSelfComponentClassHandle
    BTCurrentThread::Error.append_cause_from_component_class(
      source, message, file_name: absolute_path, line_number: lineno)
  when BTSelfMessageIterator, BTSelfMessageIteratorHandle
    BTCurrentThread::Error.append_cause_from_message_iterator(
      source, message, file_name: absolute_path, line_number: lineno)
  else
    BTCurrentThread::Error.append_cause_from_unknown(
      "babeltrace2-ruby", message, file_name: absolute_path, line_number: lineno)
  end
end

# File lib/babeltrace2/error-reporting.rb, line 391
def self.stack_ruby_error(err, source: nil)
  mess = "#{err.class}: #{err.message}"
  backtrace_locations = err.backtrace_locations
  if backtrace_locations
    err.backtrace_locations.each { |loc|
      lineno = loc.lineno
      absolute_path = loc.absolute_path
      label = loc.label
      message = ""
      if label
        message << ":in `" << label << "'"
      else
        message << "."
      end
      message << " :: " << mess if mess
      stack_error(source, message, absolute_path, lineno)
      mess = nil
    }
  else
    err.backtrace.each { |loc|
      m = loc.match(/(.*?):(\d*)([\.:].*)/)
      if m
        absolute_path = m[1]
        lineno = m[2].to_i
        message = m[3]
        message << " :: " << mess if mess
        stack_error(source, message, absolute_path, lineno)
        mess = nil
      end
    }
  end
end

# File lib/babeltrace2/error-reporting.rb, line 13
def self.verbose=(val)
  @verbose = !!val
end

# File lib/babeltrace2/error-reporting.rb, line 9
def self.verbose?
  !!@verbose
end