embulk 0.3.2 → 0.4.0

data/lib/embulk/input_plugin.rb

@@ -22,6 +22,10 @@ module Embulk
       @schema = schema
       @index = index
       @page_builder = page_builder
+      init
+    end
+
+    def init
     end
 
     def run
@@ -29,7 +33,7 @@ module Embulk
     end
 
     if Embulk.java?
-      def self.java_object
+      def self.new_java
         JavaAdapter.new(self)
       end
 
@@ -41,54 +45,64 @@ module Embulk
         end
 
         def transaction(java_config, java_control)
-          config = DataSource.from_java_object(java_config)
-          next_config_hash = @ruby_class.transaction(config) do |task_source_hash,columns,processor_count|
-            java_task_source = DataSource.from_ruby_hash(task_source_hash).java_object
-            java_schema = Schema.new(columns).java_object
+          config = DataSource.from_java(java_config)
+          config_diff_hash = @ruby_class.transaction(config) do |task_source_hash,columns,processor_count|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
+            java_schema = Schema.new(columns).to_java
             java_commit_reports = java_control.run(java_task_source, java_schema, processor_count)
             java_commit_reports.map {|java_commit_report|
-              DataSource.from_java_object(java_commit_report)
+              DataSource.from_java(java_commit_report)
             }
           end
           # TODO check return type of #transaction
-          return DataSource.from_ruby_hash(next_config_hash).java_object
+          return DataSource.from_ruby_hash(config_diff_hash).to_java
         end
 
         def resume(java_task_source, java_schema, processor_count, java_control)
-          task_source = DataSource.from_java_object(java_task_source)
-          schema = Schema.from_java_object(java_schema)
-          next_config_hash = @ruby_class.resume(task_source, schema, processor_count) do |task_source_hash,columns,processor_count|
-            java_task_source = DataSource.from_ruby_hash(task_source_hash).java_object
-            java_schema = Schema.new(columns).java_object
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
+          config_diff_hash = @ruby_class.resume(task_source, schema, processor_count) do |task_source_hash,columns,processor_count|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
+            java_schema = Schema.new(columns).to_java
             java_commit_reports = java_control.run(java_task_source, java_schema, processor_count)
             java_commit_reports.map {|java_commit_report|
-              DataSource.from_java_object(java_commit_report)
+              DataSource.from_java(java_commit_report)
             }
           end
           # TODO check return type of #resume
-          return DataSource.from_ruby_hash(next_config_hash).java_object
+          return DataSource.from_ruby_hash(config_diff_hash).to_java
         end
 
         def cleanup(java_task_source, java_schema, processor_count, java_commit_reports)
-          task_source = DataSource.from_java_object(java_task_source)
-          schema = Schema.from_java_object(java_schema)
-          commit_reports = java_commit_reports.map {|c| DataSource.from_java_object(c) }
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
+          commit_reports = java_commit_reports.map {|c| DataSource.from_java(c) }
           @ruby_class.cleanup(task_source, schema, processor_count, commit_reports)
           return nil
         end
 
         def run(java_task_source, java_schema, processor_index, java_output)
-          task_source = DataSource.from_java_object(java_task_source)
-          schema = Schema.from_java_object(java_schema)
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
           page_builder = PageBuilder.new(schema, java_output)
           begin
             commit_report_hash = @ruby_class.new(task_source, schema, processor_index, page_builder).run
-            return DataSource.from_ruby_hash(commit_report_hash).java_object
+            return DataSource.from_ruby_hash(commit_report_hash).to_java
           ensure
             page_builder.close
           end
         end
       end
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, InputPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+        end
+        # TODO
+      end
     end
   end
 

data/lib/embulk/java/bootstrap.rb

@@ -8,5 +8,10 @@ module Embulk
       #   ModelManager
       #   BufferAllocator
     end
+
+    def self.injector
+      # TODO use org.embulk.spi.Exec.getInjector
+      Injector
+    end
   end
 end

data/lib/embulk/java/imports.rb

@@ -13,6 +13,10 @@ module Embulk::Java
   java_import 'org.embulk.spi.OutputPlugin'
   java_import 'org.embulk.spi.FilterPlugin'
   java_import 'org.embulk.spi.InputPlugin'
+  java_import 'org.embulk.spi.ParserPlugin'
+  java_import 'org.embulk.spi.FormatterPlugin'
+  java_import 'org.embulk.spi.EncoderPlugin'
+  java_import 'org.embulk.spi.DecoderPlugin'
   java_import 'org.embulk.spi.TransactionalPageOutput'
   java_import 'org.embulk.spi.PageReader'
   java_import 'org.embulk.spi.PageBuilder'
@@ -22,6 +26,9 @@ module Embulk::Java
   java_import 'org.embulk.spi.Column'
   java_import 'org.embulk.spi.type.Type'
   java_import 'org.embulk.spi.type.Types'
+  java_import 'org.embulk.spi.PluginClassLoader'
+  java_import 'org.embulk.spi.FileInputRunner'
+  java_import 'org.embulk.spi.FileOutputRunner'
 
   # TODO
 end

data/lib/embulk/java_plugin.rb

@@ -0,0 +1,84 @@
+module Embulk
+
+  require 'embulk/plugin'
+
+  class JavaPlugin
+    def self.classloader(dir)
+      jars = Dir["#{dir}/**/*.jar"]
+      urls = jars.map {|jar| java.net.URL.new "file://#{File.expand_path(jar)}" }
+      classloader = Java::PluginClassLoader.new(JRuby.runtime, urls)
+    end
+
+    def self.register_input(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)  # TODO handle class not found error
+      Plugin.register_java_input(name, java_class)
+    end
+
+    def self.register_output(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_output(name, java_class)
+    end
+
+    def self.register_filter(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_filter(name, java_class)
+    end
+
+    def self.register_parser(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_parser(name, java_class)
+    end
+
+    def self.register_formatter(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_formatter(name, java_class)
+    end
+
+    def self.register_decoder(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_decoder(name, java_class)
+    end
+
+    def self.register_encoder(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_encoder(name, java_class)
+    end
+
+    def self.register_guess(name, class_fqdn, jar_dir)
+      java_class = classloader(jar_dir).loadClass(class_fqdn)
+      Plugin.register_java_guess(name, java_class)
+    end
+
+    def self.ruby_adapter_class(java_class, ruby_base_class, ruby_module)
+      Class.new(ruby_base_class) do
+        const_set(:JAVA_CLASS, java_class)
+
+        include ruby_module
+        extend ruby_module::ClassMethods
+
+        unless method_defined?(:java_object)
+          def java_object
+            @java_object ||= self.class.new_java
+          end
+        end
+
+        unless (class<<self;self;end).method_defined?(:java_class)
+          def self.java_class
+            self::JAVA_CLASS
+          end
+        end
+
+        # TODO ruby_base_class already implements new_java. So
+        #      this line returns always true:
+        #unless (class<<self;self;end).method_defined?(:new_java)
+        #      but this line could return false unexpectedly if
+        #      ruby_module::ClassMethods includes other modules.
+        unless ruby_module::ClassMethods.method_defined?(:new_java)
+          def self.new_java
+            Java.injector.getInstance(java_class)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/embulk/output_plugin.rb

@@ -22,10 +22,14 @@ module Embulk
       @task = task
       @schema = schema
       @index = index
+      init
     end
 
     attr_reader :task, :schema, :index
 
+    def init
+    end
+
     def add(page)
       raise NotImplementedError, "OutputPlugin#add(page) must be implemented"
     end
@@ -44,7 +48,7 @@ module Embulk
     end
 
     if Embulk.java?
-      def self.java_object
+      def self.new_java
         JavaAdapter.new(self)
       end
 
@@ -56,44 +60,44 @@ module Embulk
         end
 
         def transaction(java_config, java_schema, processor_count, java_control)
-          config = DataSource.from_java_object(java_config)
-          schema = Schema.from_java_object(java_schema)
-          next_config_hash = @ruby_class.transaction(config, schema, processor_count) do |task_source_hash|
-            java_task_source = DataSource.from_ruby_hash(task_source_hash).java_object
+          config = DataSource.from_java(java_config)
+          schema = Schema.from_java(java_schema)
+          config_diff_hash = @ruby_class.transaction(config, schema, processor_count) do |task_source_hash|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
             java_commit_reports = java_control.run(java_task_source)
             java_commit_reports.map {|java_commit_report|
-              DataSource.from_java_object(java_commit_report)
+              DataSource.from_java(java_commit_report)
             }
           end
           # TODO check return type of #transaction
-          return DataSource.from_ruby_hash(next_config_hash).java_object
+          return DataSource.from_ruby_hash(config_diff_hash).to_java
         end
 
         def resume(java_task_source, java_schema, processor_count, java_control)
-          task_source = DataSource.from_java_object(java_task_source)
-          schema = Schema.from_java_object(java_schema)
-          next_config_hash = @ruby_class.resume(task_source, schema, processor_count) do |task_source_hash,columns,processor_count|
-            java_task_source = DataSource.from_ruby_hash(task_source_hash).java_object
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
+          config_diff_hash = @ruby_class.resume(task_source, schema, processor_count) do |task_source_hash,columns,processor_count|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
             java_commit_reports = java_control.run(java_task_source)
             java_commit_reports.map {|java_commit_report|
-              DataSource.from_java_object(java_commit_report)
+              DataSource.from_java(java_commit_report)
             }
           end
           # TODO check return type of #resume
-          return DataSource.from_ruby_hash(next_config_hash).java_object
+          return DataSource.from_ruby_hash(config_diff_hash).to_java
         end
 
         def cleanup(java_task_source, java_schema, processor_count, java_commit_reports)
-          task_source = DataSource.from_java_object(java_task_source)
-          schema = Schema.from_java_object(java_schema)
-          commit_reports = java_commit_reports.map {|c| DataSource.from_java_object(c) }
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
+          commit_reports = java_commit_reports.map {|c| DataSource.from_java(c) }
           @ruby_class.cleanup(task_source, schema, processor_count, commit_reports)
           return nil
         end
 
         def open(java_task_source, java_schema, processor_index)
-          task_source = DataSource.from_java_object(java_task_source)
-          schema = Schema.from_java_object(java_schema)
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
           ruby_object = @ruby_class.new(task_source, schema, processor_index)
           return OutputAdapter.new(ruby_object, schema)
         end
@@ -107,6 +111,7 @@ module Embulk
           end
 
           def add(java_page)
+            # TODO reuse page reader
             @ruby_object.add Page.new(java_page, @schema)
           end
 
@@ -124,10 +129,21 @@ module Embulk
 
           def commit
             commit_report_hash = @ruby_object.commit
-            return DataSource.from_ruby_hash(commit_report_hash).java_object
+            return DataSource.from_ruby_hash(commit_report_hash).to_java
           end
         end
       end
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, OutputPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+          # TODO transaction, resume, cleanup
+        end
+        # TODO add, finish, close, abort, commit
+      end
     end
   end
 

data/lib/embulk/page.rb

@@ -15,7 +15,7 @@ module Embulk
 
     def each
       schema = @schema
-      reader = Java::PageReader.new(schema.java_object)
+      reader = Java::PageReader.new(schema.to_java)
       begin
         reader.setPage(@java_page)
         while reader.nextRecord

data/lib/embulk/page_builder.rb

@@ -2,7 +2,7 @@ module Embulk
 
   class PageBuilder
     def initialize(schema, java_page_output)
-      @page_builder = Java::PageBuilder.new(Java::Injected::BufferAllocator, schema.java_object, java_page_output)
+      @page_builder = Java::PageBuilder.new(Java::Injected::BufferAllocator, schema.to_java, java_page_output)
       @schema = schema
     end
 

data/lib/embulk/parser_plugin.rb

@@ -0,0 +1,76 @@
+module Embulk
+
+  require 'embulk/data_source'
+  require 'embulk/schema'
+  require 'embulk/page_builder'
+  #require 'embulk/file_input'  TODO not implemented
+
+  class ParserPlugin
+    def self.transaction(config, &control)
+      raise NotImplementedError, "ParserPlugin.transaction(config, &control) must be implemented"
+    end
+
+    def initialize(task, schema, page_builder)
+      @task = task
+      @schema = schema
+      @page_builder = page_builder
+      init
+    end
+
+    def init
+    end
+
+    def run(file_input)
+      raise NotImplementedError, "ParserPlugin#run(file_input) must be implemented"
+    end
+
+    if Embulk.java?
+      def self.new_java
+        JavaAdapter.new(self)
+      end
+
+      class JavaAdapter
+        include Java::ParserPlugin
+
+        def initialize(ruby_class)
+          @ruby_class = ruby_class
+        end
+
+        def transaction(java_config, java_control)
+          config = DataSource.from_java(java_config)
+          @ruby_class.transaction(config) do |task_source_hash,columns|
+            java_task_source = DataSource.from_ruby_hash(task_source_hash).to_java
+            java_schema = Schema.new(columns).to_java
+            java_control.run(java_task_source, java_schema)
+          end
+          nil
+        end
+
+        def run(java_task_source, java_schema, java_file_input, java_output)
+          task_source = DataSource.from_java(java_task_source)
+          schema = Schema.from_java(java_schema)
+          file_input = FileInput.from_java(java_file_input)
+          page_builder = PageBuilder.new(schema, java_output)
+          begin
+            @ruby_class.new(task_source, schema, page_builder).run(file_input)
+            nil
+          ensure
+            page_builder.close
+            # FileInput is closed by FileInputRunner
+          end
+        end
+      end
+
+      def self.from_java(java_class)
+        JavaPlugin.ruby_adapter_class(java_class, ParserPlugin, RubyAdapter)
+      end
+
+      module RubyAdapter
+        module ClassMethods
+        end
+        # TODO
+      end
+    end
+  end
+
+end

data/lib/embulk/plugin.rb

@@ -4,19 +4,22 @@ module Embulk
   require 'embulk/error'
   require 'embulk/plugin_registry'
   require 'embulk/input_plugin'
-  require 'embulk/filter_plugin'
+  require 'embulk/file_input_plugin'
   require 'embulk/output_plugin'
-  #require 'embulk/parser_plugin'
-  #require 'embulk/formatter_plugin'
-  #require 'embulk/decoder_plugin'
-  #require 'embulk/encoder_plugin'
+  require 'embulk/file_output_plugin'
+  require 'embulk/filter_plugin'
+  require 'embulk/parser_plugin'
+  require 'embulk/formatter_plugin'
+  require 'embulk/decoder_plugin'
+  require 'embulk/encoder_plugin'
   require 'embulk/guess_plugin'
+  require 'embulk/java_plugin' if Embulk.java?
 
   class PluginManager
     def initialize
       @registries = {}
       %w[input output parser formatter decoder encoder line_filter filter guess].each do |category|
-        @registries[category.to_sym] = PluginRegistry.new(category, "embulk/#{category}_")
+        @registries[category.to_sym] = PluginRegistry.new(category, "embulk/#{category}/")
       end
     end
 
@@ -29,101 +32,150 @@ module Embulk
                       "Output plugin #{klass} must extend OutputPlugin")
     end
 
-    def register_parser(type, klass)
-      register_plugin(:parser, type, klass, ParserPlugin)
+    def register_filter(type, klass)
+      register_plugin(:filter, type, klass, FilterPlugin)
     end
 
-    def register_formatter(type, klass)
-      register_plugin(:formatter, type, klass, FormatterPlugin)
-    end
+    ## TODO FileInput is not implemented yet.
+    #def register_parser(type, klass)
+    #  register_plugin(:parser, type, klass, ParserPlugin)
+    #end
 
-    def register_decoder(type, klass)
-      register_plugin(:decoder, type, klass, DecoderPlugin)
-    end
+    ## TODO FileOutput is not implemented yet.
+    #def register_formatter(type, klass)
+    #  register_plugin(:formatter, type, klass, FormatterPlugin)
+    #end
 
-    def register_encoder(type, klass)
-      register_plugin(:encoder, type, klass, EncoderPlugin)
-    end
+    ## TODO DecoderPlugin JRuby API is not written by anyone yet
+    #def register_decoder(type, klass)
+    #  register_plugin(:decoder, type, klass, DecoderPlugin)
+    #end
 
-    def register_filter(type, klass)
-      register_plugin(:filter, type, klass, FilterPlugin)
-    end
+    ## TODO EncoderPlugin JRuby API is not written by anyone yet
+    #def register_encoder(type, klass)
+    #  register_plugin(:encoder, type, klass, EncoderPlugin)
+    #end
 
     def register_guess(type, klass)
       register_plugin(:guess, type, klass, GuessPlugin,
                      "Guess plugin #{klass} must extend GuessPlugin, LineGuessPlugin, or TextGuessPlugin class")
     end
 
-    def get_input(type)
-      # TODO not implemented yet
+    # TODO InputPlugin::RubyAdapter is not written by anyone yet
+    #def get_input(type)
+    #  lookup(:input, type)
+    #end
+
+    # TODO OutputPlugin::RubyAdapter is not written by anyone yet
+    #def get_output(type)
+    #  lookup(:output, type)
+    #end
+
+    # TODO FilterPlugin::RubyAdapter is not written by anyone yet
+    #def get_filter(type)
+    #  lookup(:filter, type)
+    #end
+
+    # TODO FilterPlugin::RubyAdapter is not written by anyone yet
+    #def get_parser(type)
+    #  # TODO not implemented yet
+    #  lookup(:parser, type)
+    #end
+
+    # TODO FormatterPlugin::RubyAdapter is not written by anyone yet
+    #def get_formatter(type)
+    #  # TODO not implemented yet
+    #  lookup(:formatter, type)
+    #end
+
+    # TODO DecoderPlugin::RubyAdapter is not written by anyone yet
+    #def get_decoder(type)
+    #  # TODO not implemented yet
+    #  lookup(:decoder, type)
+    #end
+
+    # TODO EncoderPlugin::RubyAdapter is not written by anyone yet
+    #def get_encoder(type)
+    #  # TODO not implemented yet
+    #  lookup(:encoder, type)
+    #end
+
+    def get_guess(type)
       lookup(:guess, type)
     end
 
-    def get_output(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_input(type, klass)
+      register_java_plugin(:input, type, klass,
+                           "org.embulk.spi.InputPlugin" => InputPlugin,
+                           "org.embulk.spi.FileInputPlugin" => FileInputPlugin)
     end
 
-    def get_parser(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_output(type, klass)
+      register_java_plugin(:output, type, klass,
+                           "org.embulk.spi.OutputPlugin" => OutputPlugin,
+                           "org.embulk.spi.FileOutputPlugin" => FileOutputPlugin)
     end
 
-    def get_formatter(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_filter(type, klass)
+      register_java_plugin(:filter, type, klass,
+                           "org.embulk.spi.FilterPlugin" => FilterPlugin)
     end
 
-    def get_decoder(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_parser(type, klass)
+      register_java_plugin(:parser, type, klass,
+                           "org.embulk.spi.ParserPlugin" => ParserPlugin)
     end
 
-    def get_encoder(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_formatter(type, klass)
+      register_java_plugin(:formatter, type, klass,
+                           "org.embulk.spi.FormatterPlugin" => FormatterPlugin)
     end
 
-    def get_filter(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_decoder(type, klass)
+      register_java_plugin(:decoder, type, klass,
+                           "org.embulk.spi.DecoderPlugin" => DecoderPlugin)
     end
 
-    def get_guess(type)
-      # TODO not implemented yet
-      lookup(:guess, type)
+    def register_java_encoder(type, klass)
+      register_java_plugin(:encoder, type, klass,
+                           "org.embulk.spi.EncoderPlugin" => EncoderPlugin)
+    end
+
+    def register_java_guess(type, klass)
+      register_java_plugin(:guess, type, klass,
+                           "org.embulk.spi.GuessPlugin" => GuessPlugin)
     end
 
     def new_java_input(type)
-      lookup(:input, type).java_object
+      lookup(:input, type).new_java
     end
 
     def new_java_output(type)
-      lookup(:output, type).java_object
+      lookup(:output, type).new_java
+    end
+
+    def new_java_filter(type)
+      lookup(:filter, type).new_java
     end
 
     def new_java_parser(type)
-      lookup(:parser, type).java_object
+      lookup(:parser, type).new_java
     end
 
     def new_java_formatter(type)
-      lookup(:formatter, type).java_object
+      lookup(:formatter, type).new_java
     end
 
     def new_java_decoder(type)
-      lookup(:decoder, type).java_object
+      lookup(:decoder, type).new_java
     end
 
     def new_java_encoder(type)
-      lookup(:encoder, type).java_object
-    end
-
-    def new_java_filter(type)
-      lookup(:filter, type).java_object
+      lookup(:encoder, type).new_java
     end
 
     def new_java_guess(type)
-      lookup(:guess, type).java_object
+      lookup(:guess, type).new_java
     end
 
     private
@@ -136,13 +188,26 @@ module Embulk
       @registries[category].lookup(type)
     end
 
-    def register_plugin(category, type, klass, iface, message=nil)
-      unless klass < iface
-        message ||= "Plugin #{klass} must implement #{iface}"
+    def register_plugin(category, type, klass, base_class, message=nil)
+      unless klass < base_class
+        message ||= "Plugin #{klass} must inherit #{base_class}"
         raise message
       end
       @registries[category].register(type, klass)
     end
+
+    def register_java_plugin(category, type, klass, iface_map, message=nil)
+      found = iface_map.find do |iface_name,ruby_base_class|
+        iface = JRuby.runtime.getJRubyClassLoader.load_class(iface_name)
+        iface.isAssignableFrom(klass)
+      end
+      unless found
+        message ||= "Java plugin #{klass} must implement #{iface_map.keys.join(' or ')}"
+        raise message
+      end
+      adapted = found.last.from_java(klass)
+      @registries[category].register(type, adapted)
+    end
   end
 
   module Plugin
@@ -152,14 +217,14 @@ module Embulk
       extend Forwardable
 
       def_delegators 'INSTANCE',
-        :register_input, :get_input, :new_java_input,
-        :register_output, :get_output, :new_java_output,
-        :register_parser, :get_parser, :new_java_parser,
-        :register_formatter, :get_formatter, :new_java_formatter,
-        :register_decoder, :get_decoder, :new_java_decoder,
-        :register_encoder, :get_encoder, :new_java_encoder,
-        :register_filter, :get_filter, :new_java_filter,
-        :register_guess, :get_guess, :new_java_guess
+        :register_input, :get_input, :register_java_input, :new_java_input,
+        :register_output, :get_output, :register_java_output, :new_java_output,
+        :register_filter, :get_filter, :register_java_filter, :new_java_filter,
+        :register_parser, :get_parser, :register_java_parser, :new_java_parser,
+        :register_formatter, :get_formatter, :register_java_formatter, :new_java_formatter,
+        :register_decoder, :get_decoder, :register_java_decoder, :new_java_decoder,
+        :register_encoder, :get_encoder, :register_java_encoder, :new_java_encoder,
+        :register_guess, :get_guess, :register_java_guess, :new_java_guess
     end
   end
 end