[Java] Een short opdelen in 2 bytes

[Boondock_Saint]

Ik ben bezig met een chat-protocol en dat werkt als volgt: De eerste 2 bytes geven de lengte van het record in bytes aan (integer getal), de tweede 2 bytes geven het type van het bericht aan (ook een integer getal) en de rest van de bytes zijn parameters.

Nu heb ik een wrapper class geschreven en dat gaat prima voor binnenkomende berichten. Om je een idee te geven:

code:

       /**
     * The constructor for incoming messages.
     * @param rawData The bitstream that is received from another host.
     */
    public Message(short type, byte[] rawData)
    {
        StringTokenizer allParameters;
        this.length = (short) rawData.length;
        this.type = type;
        this.rawData = rawData;
        
        /* If this message contains parameters */
        if(length > 4) {
            try {
                allParameters = new StringTokenizer(new String(rawData, 4, rawData.length - 4, "US-ASCII"), " \t");
                if(allParameters.hasMoreTokens()) {
                    param1 = allParameters.nextToken();
                }
                
                if(allParameters.hasMoreTokens()) {
                    param2 = allParameters.nextToken();
                }
                
                while(allParameters.hasMoreTokens()) {
                    param3 += allParameters.nextToken();
                }
            } catch (UnsupportedEncodingException e) {
                System.out.println("Unsupported charset");
            }
        }
    }

Zoals je ziet krijgt deze constructor het type ook apart, omdat ik readShort kan gebruiken. Eigenlijk zou deze dan ook in rawData[2] en rawData[3] moeten zitten.

Voor uitgaande berichten is het echter wel een probleem. Ik kan natuurlijk iets van sendShort gebruiken, maar het zou veel makkelijker zijn als alles gewoon in die array zit, zodat ik het met een loopje kan opsturen.

Helaas heeft Java dus geen bitwise operatoren. Ik heb al flink in de API zitten spitten. Short.byteValue werkt bijvoorbeeld niet voor shorts die groter zijn dan Byte.MAX_VALUE en rawData = new String("" + length + type).getBytes("US-ASCII"); levert een array met de ascii codes van de getallen, terwijl de eerste twee byte-paren een integer getal moeten voorstellen.

Waarom doe je het dan niet in C?
Goede vraag Het is een opdracht voor school en mijn groepje heeft Java gekozen. Ook is het protocol dus niet te wijzigen (dat is de opdracht).

Wat wil je dan precies?
Eigenlijk dit:

code:

short length;
length = rawData[0] << 8;
length = length | rawData[1];

[momania]

Boondock_Saint schreef op maandag 10 april 2006 @ 15:29:

Wat wil je dan precies?
Eigenlijk dit:

code:

short length;
length = rawData[0] << 8;
length = length & rawData[1];

Waarom doe je dat dan niet? Bitwise operators bestaan wel degelijk in java

[JKVA]

Ja, maar niet op deze manier, want zo compileert het niet. Een bitwise operator returnt altijd een int en die kun je niet in een short zetten. Even naar int casten is dus wel handig. Of van je "length" variabele een int maken...

[Boondock_Saint]

momania schreef op maandag 10 april 2006 @ 15:32:
[...]

Waarom doe je dat dan niet? Bitwise operators bestaan wel degelijk in java

Lekker boek heb ik hier dan! Thanx.

[Robtimus]

JKVA schreef op maandag 10 april 2006 @ 15:35:
Ja, maar niet op deze manier, want zo compileert het niet. Een bitwise operator returnt altijd een int en die kun je niet in een short zetten. Even naar int casten is dus wel handig. Of van je "length" variabele een int maken...

code:

short length;
length = (short)(rawData[0] << 8);
length = (short)(length & rawData[1]);

Zolang je maar zeker weet dat rawData[0] << 8 in een short past (is zo) en length & rawData[1] ook (is zo) dan is er geen probleem.

Maare, Boondock, bedoel je niet length | rawData[1]?
Edit: ja dus

[ Voor 5% gewijzigd door Robtimus op 10-04-2006 19:38 ]