public RubyIconv(Ruby runtime,
    RubyClass type) 
{
         
        super(runtime, type);
}

 public static IRubyObject charset_map_get(IRubyObject recv) 
{
        return recv.getRuntime().getCharsetMap();
}

 public IRubyObject close() 
{
        toEncoding = null;
        fromEncoding = null;
        return RubyString.newEmptyString(getRuntime());
}

 public static IRubyObject conv(ThreadContext context,
    IRubyObject recv,
    IRubyObject[] args,
    Block unusedBlock) 
{
        return convertWithArgs(context, recv, args, "conv").join(context, RubyString.newEmptyString(recv.getRuntime()));
}

 public static RubyArray convertWithArgs(ThreadContext context,
    IRubyObject recv,
    IRubyObject[] args,
    String function) 
{
        assert args.length  >= 2;
        RubyArray array = context.getRuntime().newArray(args.length - 2);
        RubyIconv iconv = newIconv(context, recv, args[0], args[1]);
        try {
            for (int i = 2; i <  args.length; i++) {
                array.append(iconv.iconv(args[i]));
            }
        } finally {
            iconv.close();
        }
        return array;
}

 public static  void createIconv(Ruby runtime) 
{
        RubyClass iconvClass = runtime.defineClass("Iconv", runtime.getObject(), ICONV_ALLOCATOR);
        iconvClass.defineAnnotatedMethods(RubyIconv.class);
        RubyModule failure = iconvClass.defineModuleUnder("Failure");
        RubyClass argumentError = runtime.getArgumentError();
        String[] iconvErrors = {"IllegalSequence", "InvalidCharacter", "InvalidEncoding", 
                "OutOfRange", "BrokenLibrary"};
        for (int i = 0; i <  iconvErrors.length; i++) {
            RubyClass subClass = iconvClass.defineClassUnder(iconvErrors[i], argumentError, RubyFailure.ICONV_FAILURE_ALLOCATOR);
            subClass.defineAnnotatedMethods(RubyFailure.class);
            subClass.includeModule(failure);
        }
}

 public IRubyObject iconv(IRubyObject str) 
{
        return iconv(str, 0, -1);
}

 public IRubyObject iconv(IRubyObject[] args) 
{
        switch (args.length) {
        case 1:
            return iconv(args[0]);
        case 2:
            return iconv(args[0], args[1]);
        case 3:
            return iconv(args[0], args[1], args[2]);
        default:
            Arity.raiseArgumentError(getRuntime(), args.length, 1, 2);
            return null; // not reached
        }
}

Variable-arity version for compatibility. Not bound to Ruby.

 public IRubyObject iconv(IRubyObject str,
    IRubyObject startArg) 
{
        int start = 0;
        if (!startArg.isNil()) start = RubyNumeric.fix2int(startArg);
        return iconv(str, start, -1);
}

 public IRubyObject iconv(IRubyObject str,
    IRubyObject startArg,
    IRubyObject endArg) 
{
        int start = 0;
        int end = -1;
        if (!startArg.isNil()) start = RubyNumeric.fix2int(startArg);
        if (!endArg.isNil()) end = RubyNumeric.fix2int(endArg);
        return iconv(str, start, end);
}

 public static IRubyObject iconv(ThreadContext context,
    IRubyObject recv,
    IRubyObject[] args,
    Block unusedBlock) 
{
        return convertWithArgs(context, recv, args, "iconv");
}

 public IRubyObject initialize(IRubyObject arg1,
    IRubyObject arg2,
    Block unusedBlock) 
{
        Ruby runtime = getRuntime();
        if (!arg1.respondsTo("to_str")) {
            throw runtime.newTypeError("can't convert " + arg1.getMetaClass() + " into String");
        }
        if (!arg2.respondsTo("to_str")) {
            throw runtime.newTypeError("can't convert " + arg2.getMetaClass() + " into String");
        }
        String to = arg1.convertToString().toString();
        String from = arg2.convertToString().toString();
        try {
            fromEncoding = Charset.forName(getCharset(from)).newDecoder();
            toEncoding = Charset.forName(getCharset(to)).newEncoder();
            if (!isIgnore(from)) fromEncoding.onUnmappableCharacter(CodingErrorAction.REPORT);
            if (!isIgnore(to)) toEncoding.onUnmappableCharacter(CodingErrorAction.REPORT);
        } catch (IllegalCharsetNameException e) {
            throw runtime.newInvalidEncoding("invalid encoding");
        } catch (UnsupportedCharsetException e) {
            throw runtime.newInvalidEncoding("invalid encoding");
        } catch (Exception e) {
            throw runtime.newSystemCallError(e.toString());
        }
        return this;
}

 public static IRubyObject open(ThreadContext context,
    IRubyObject recv,
    IRubyObject to,
    IRubyObject from,
    Block block) 
{
        Ruby runtime = context.getRuntime();
        RubyIconv iconv = newIconv(context, recv, to, from);
        if (!block.isGiven()) return iconv;
        IRubyObject result = runtime.getNil();
        try {
            result = block.yield(context, iconv);
        } finally {
            iconv.close();
        }
        return result;
}