org/objectweb/proactive/mpi/control/util/ProActiveMPIUtil.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.mpi.control.util;


public class ProActiveMPIUtil {
    public static final int BYTE_LEN = 1;
    public static final int SHORT_LEN = 2;
    public static final int INT_LEN = 4;
    public static final int FLOAT_LEN = 4;
    public static final int LONG_LEN = 8;
    public static final int DOUBLE_LEN = 8;

    public static int intToBytes(int num, byte[] bytes, int startIndex) {
        bytes[startIndex] = (byte) (num & 0xff);
        bytes[startIndex + 1] = (byte) ((num >> 8) & 0xff);
        bytes[startIndex + 2] = (byte) ((num >> 16) & 0xff);
        bytes[startIndex + 3] = (byte) ((num >> 24) & 0xff);
        return startIndex + 4;
    }

    public static int bytesToInt(byte[] bytes, int startIndex) {
        return (((int) bytes[startIndex] & 0xff) |
        (((int) bytes[startIndex + 1] & 0xff) << 8) |
        (((int) bytes[startIndex + 2] & 0xff) << 16) |
        (((int) bytes[startIndex + 3] & 0xff) << 24));
    }

    public static int floatToBytes(float fnum, byte[] bytes, int startIndex) {
        return intToBytes(Float.floatToIntBits(fnum), bytes, startIndex);
    }

    public static float bytesToFloat(byte[] bytes, int startIndex) {
        return (Float.intBitsToFloat(bytesToInt(bytes, startIndex)));
    }

    public static int shortToBytes(short num, byte[] bytes, int startIndex) {
        bytes[startIndex] = (byte) (num & 0xff);
        bytes[startIndex + 1] = (byte) ((num >> 8) & 0xff);
        return startIndex + 2;
    }

    public static short bytesToShort(byte[] bytes, int startIndex) {
        return (short) (((int) bytes[startIndex] & 0xff) |
        (((int) bytes[startIndex + 1] & 0xff) << 8));
    }

    public static int stringToBytes(String str, byte[] bytes, int startIndex) {
        byte[] temp;
        int len = str.length();

        temp = str.getBytes();
        if (len > 255) {
            System.err.println(
                "String has more than 255 bytes in \"stringToBytes\", it will be truncated.");

            bytes[startIndex++] = (byte) 255;
            System.arraycopy(temp, 0, bytes, startIndex, 255);
            return startIndex + 255;
        } else {
            bytes[startIndex++] = (byte) len;
            System.arraycopy(temp, 0, bytes, startIndex, len);
            return startIndex + len;
        }
    }

    public static String bytesToString(byte[] bytes, int startIndex) {
        int len = (int) (bytes[startIndex++]) & 0xff;
        return new String(bytes, startIndex, len);
    }

    public static int longToBytes(long lnum, byte[] bytes, int startIndex) {
        for (int i = 0; i < 8; i++)
            bytes[startIndex + i] = (byte) ((lnum >> (i * 8)) & 0xff);
        return startIndex + 8;
    }

    public static long bytesToLong(byte[] bytes, int startIndex) {
        // the lower 4 bytes
        //      long temp = (long)bytesToInt(bytes, startIndex) & (long)0xffffffff;
        //return temp | ((long)bytesToInt(bytes, startIndex+4) << 32);
        return (((long) bytes[startIndex] & 0xff) |
        (((long) bytes[startIndex + 1] & 0xff) << 8) |
        (((long) bytes[startIndex + 2] & 0xff) << 16) |
        (((long) bytes[startIndex + 3] & 0xff) << 24) |
        (((long) bytes[startIndex + 4] & 0xff) << 32) |
        (((long) bytes[startIndex + 5] & 0xff) << 40) |
        (((long) bytes[startIndex + 6] & 0xff) << 48) |
        (((long) bytes[startIndex + 7] & 0xff) << 56));
    }

    public static int doubleToBytes(double dnum, byte[] bytes, int startIndex) {
        return longToBytes(Double.doubleToLongBits(dnum), bytes, startIndex);
    }

    public static double bytesToDouble(byte[] bytes, int startIndex) {
        return Double.longBitsToDouble(bytesToLong(bytes, startIndex));
    }
}

---