Java

Socket Send/Receive 16-bit Integers

Demonstrates sending and receiving 16-bit integers over a socket connection using either big-endian or little-endian byte ordering. Chilkat2 Java

import com.chilkatsoft.chilkat2.ChilkatException;
import com.chilkatsoft.chilkat2.Socket;

public class ChilkatExample {

    public static void main(String[] args) {
        // This example requires the Chilkat API to have been previously unlocked.
        // See Global Unlock Sample for sample code.

        Socket sock = new Socket();

        // --------------------------------------------------------------------
        // This example uses the public TCP echo service at https://tcpbin.com/
        // --------------------------------------------------------------------

        boolean useTls = false;
        int port = 4242;
        int maxWaitMs = 5000;
        try {
            sock.connect("tcpbin.com", port, useTls, maxWaitMs);
        } catch (ChilkatException e) {
            System.out.println(e.getLastErrorText());
            return;
        }

        // Wait a max of 2 seconds for a response..
        sock.setMaxReadIdleMs(2000);

        // Send a 16-bit integer using big-endian byte ordering (also called network byte order)
        // 12022 decimal = 2EF6 hex
        int value = 12022;
        boolean bigEndian = true;
        sock.sendInt16(value, bigEndian);
        // Send it again, because we'll read it two different ways..
        sock.sendInt16(value, bigEndian);

        // The tcpbin.com echo server only echoes after receiving an LF (linefeed char)
        sock.sendByte(10);

        // Let's see hex values of the 2 bytes sent in network byte order (big-endian)
        // (The echo server sends back exactly the bytes received.)
        String hexStr = sock.receiveNBytesENC(2, "hex");

        // In the big-ending byte order, the byte order is most significant byte to least significant,
        // therefore we should see the bytes in the order 0x2E 0xF6.
        System.out.println("Expecting big-endian 2EF6");
        System.out.println(hexStr);

        // Let's read directly to an integer..
        sock.receiveInt16(bigEndian, true);
        System.out.println("Expecting 12022");
        System.out.println("Received: " + sock.getReceivedInt());

        // Consume the LF that gets echoed back..
        sock.receiveByte(true);

        // --------------------------------------------------------------------
        // Let's do the same thing, but with little-endian byte ordering.

        System.out.println("----");

        // 12022 decimal = 2EF6 hex, but little-endian byte ordering will send the bytes in the order 0xF6 0x2E
        value = 12022;
        bigEndian = false;
        sock.sendInt16(value, bigEndian);
        sock.sendInt16(value, bigEndian);
        sock.sendByte(10);

        hexStr = sock.receiveNBytesENC(2, "hex");

        System.out.println("Expecting little-endian F62E");
        System.out.println(hexStr);

        sock.receiveInt16(bigEndian, true);
        System.out.println("Expecting 12022");
        System.out.println("Received: " + sock.getReceivedInt());

        // Consume the LF that gets echoed back..
        sock.receiveByte(true);

        sock.closeConnection(1000);

        // Output:

        // Expecting big-endian 2EF6
        // 2EF6
        // Expecting 12022
        // Received: 12022
        // ----
        // Expecting little-endian F62E
        // F62E
        // Expecting 12022
        // Received: 12022
    }
}