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

 static  void createTCPSocket(Ruby runtime) 
{
        RubyClass rb_cTCPSocket = runtime.defineClass("TCPSocket", runtime.fastGetClass("IPSocket"), TCPSOCKET_ALLOCATOR);
        rb_cTCPSocket.includeModule(runtime.fastGetClass("Socket").fastGetConstant("Constants"));
        rb_cTCPSocket.defineAnnotatedMethods(RubyTCPSocket.class);
        runtime.getObject().fastSetConstant("TCPsocket",rb_cTCPSocket);
}

 public static IRubyObject gethostbyname(IRubyObject recv,
    IRubyObject hostname) 
{
        try {
            IRubyObject[] ret = new IRubyObject[4];
            Ruby r = recv.getRuntime();
            InetAddress addr;
            String hostString = hostname.convertToString().toString();
            addr = InetAddress.getByName(hostString);
            ret[0] = r.newString(addr.getCanonicalHostName());
            ret[1] = r.newArray();
            ret[3] = r.newString(addr.getHostAddress());
            if (addr instanceof Inet4Address) {
                Inet4Address addr4 = (Inet4Address)addr;
                ret[2] = r.newFixnum(RubySocket.AF_INET); //AF_INET
            } else if (addr instanceof Inet6Address) {
                Inet6Address addr6 = (Inet6Address)addr;
                ret[2] = r.newFixnum(RubySocket.AF_INET6); //AF_INET
            }
            return r.newArrayNoCopy(ret);
        } catch(UnknownHostException e) {
            throw sockerr(recv, "gethostbyname: name or service not known");
        }
}

 public IRubyObject initialize(IRubyObject[] args) 
{
        Arity.checkArgumentCount(getRuntime(), args, 2, 4);
        String remoteHost = args[0].isNil()? "localhost" : args[0].convertToString().toString();
        int remotePort = getPortFrom(args[1]);
        String localHost = args.length  >= 3 ? args[2].convertToString().toString() : null;
        int localPort = args.length == 4 ? getPortFrom(args[3]) : 0;
        try {
            SocketChannel channel = null;
            if(localHost == null) {
                InetSocketAddress addr = new InetSocketAddress(InetAddress.getByName(remoteHost), remotePort);
                channel = SocketChannel.open(addr);
            } else {
                channel = SocketChannel.open();
                Socket socket = channel.socket();
                socket.bind(new InetSocketAddress(InetAddress.getByName(localHost), localPort));
                socket.connect(new InetSocketAddress(InetAddress.getByName(remoteHost), remotePort));
            }
            channel.finishConnect();
            initSocket(new ChannelDescriptor(channel, RubyIO.getNewFileno(), new ModeFlags(ModeFlags.RDWR), new FileDescriptor()));
        } catch (InvalidValueException ex) {
            throw getRuntime().newErrnoEINVALError();
        } catch(ConnectException e) {
            throw getRuntime().newErrnoECONNREFUSEDError();
        } catch(UnknownHostException e) {
            throw sockerr(this, "initialize: name or service not known");
        } catch(IOException e) {
            throw sockerr(this, "initialize: name or service not known");
        }
        return this;
}

 public static IRubyObject open(IRubyObject recv,
    IRubyObject[] args,
    Block block) 
{
        RubyTCPSocket sock = (RubyTCPSocket)recv.callMethod(recv.getRuntime().getCurrentContext(),"new",args);
        if (!block.isGiven()) return sock;
        try {
            return block.yield(recv.getRuntime().getCurrentContext(), sock);
        } finally {
            if (sock.openFile.isOpen()) sock.close();
        }
}