Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *   Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *   +34 963862235

 *   gvsig@gva.es

 *   http://www.gvsig.gva.es

 *

 *    or

 *

 *   Prodevelop Integraci?n de Tecnolog?as SL

 *   Conde Salvatierra de ?lava , 34-10

 *   46004 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   gis@prodevelop.es

 *   http://www.prodevelop.es

 *

 *    or

 *

 *   Instituto de Rob?tica

 *   Apartado de correos 2085

 *   46071 Valencia

 *   (Spain)

 *   

 *   +34 963 543 577

 *   jjordan@robotica.uv.es

 *   http://robotica.uv.es

 *   

 */

package org.gvsig.datasources.impljme;

import java.nio.ByteOrder;

import org.apache.log4j.Logger;

import org.gvsig.datasources.common.IByteBuffer;

/**

 * This class replaces the byte buffer used in J2SE to store a file in memory.

 * 

 * @see java.nio.ByteOrder

 * 

 * @author jldominguez

 *

 */

public class ByteBufferJME implements IByteBuffer {

        private static Logger logger = Logger.getLogger(ByteBufferJME.class);

        private byte[] bytes;

        private ByteOrder byteOrder = ByteOrder.LITTLE_ENDIAN;

        private int pos = 0;

        public ByteBufferJME(int size) {

                bytes = new byte[size];

        }

        public ByteBufferJME(byte[] bb) {

                bytes = bb;

        }

        public void get(byte[] out) {

                int canread = bytes.length - pos;

                canread = Math.min(canread, out.length);

                System.arraycopy(bytes, pos, out, 0, canread);

                pos = pos + canread;

        }

        public void put(byte[] input) {

                int canwrite = bytes.length - pos;

                if (canwrite < input.length) {

                        logger.error("Byte buffer too short to write " + input.length + " bytes. Nothing done.");

                        return;

                }

                System.arraycopy(input, 0, bytes, pos, input.length);

                pos = pos + input.length;

        }

        public IByteBuffer flip() {

                byte[] newbytes = new byte[pos];

                System.arraycopy(bytes, 0, newbytes, 0, pos);

                bytes = newbytes;

                pos = 0;

                return this;

        }

        public void order(ByteOrder o) {

                byteOrder = o;

        }

        public void put(byte b) {

                if (pos == bytes.length) {

                        logger.error("Cannot put one byte, we are at the end. Nothing done.");

                } else {

                        bytes[pos] = b;

                        pos++;

                }

        }

        public int position() {

                return pos;

        }

        public int remaining() {

                return bytes.length - pos;

        }

        public void rewind() {

                pos = 0;

        }

        public ByteOrder order() {

                return byteOrder;

        }

        public byte get() {

                if (pos == bytes.length) {

                        logger.error("Cannot get one byte, we are at the end. Returned 0.");

                        return 0;

                } else {

                        pos++;

                        return bytes[pos-1]; 

                }

        }

        public int capacity() {

                return bytes.length;

        }

        public IByteBuffer limit(int newlimit) {

                if ((newlimit <= 0) || (newlimit > bytes.length)) {

                        logger.error("Invalid new limit: " + newlimit + ". Nothing done.");

                        return this;

                }

                byte[] newbytes = new byte[newlimit];

                System.arraycopy(bytes, 0, newbytes, 0, newlimit);

                bytes = newbytes;

                if (pos > newlimit) {

                        pos = newlimit;

                }

                return this;

        }

        public int limit() {

                return bytes.length;

        }

        public void position(int newp) {

                pos = newp;

        }

        public double getDouble() {

                double resp = getDouble(bytes, pos);

                pos = pos + 8;

                return resp;

        }

        public int getInt() {

                int resp = getInt(bytes, pos);

                pos = pos + 4;

                return resp;

        }

        // ==============================

        private long getNumber(final byte[] data, final int offset, final int size) {

        long result = 0;

        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {

            for (int j = offset + size - 1; j >= offset; j--) {

                result <<= 8;

                result |= 0xff & data[j];

            }

        } else {

            for (int j = offset; j <= offset + size - 1; j++) {

                result <<= 8;

                result |= 0xff & data[j];

            }

        }

        return result;

    }

        private void putNumber(final byte[] number) {

        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {

                byte[] reversed = reverse(number);

                put(reversed);

        } else {

                put(number);

        }

    }

        private static byte[] reverse(byte[] b) {

                int l = b.length;

                byte[] resp = new byte[l];

                for (int i=0; i<l; i++) {

                        resp[i] = b[l - 1 - i]; 

                }

                return resp;

        }

        private double getDouble(final byte[] data, final int offset) {

        return Double.longBitsToDouble(getNumber(data, offset, 8));

    }

        private int getInt(final byte[] data, final int offset) {

        return (int) getNumber(data, offset, 4);

    }

        private short getShort(final byte[] data, final int offset) {

        return (short) getNumber(data, offset, 2);

    }

        public void putDouble(double v) {

                long vlong = Double.doubleToLongBits(v);

                byte[] vbytes = longToByteArray(vlong, 8);

                putNumber(vbytes);

    }

        public void putInt(int v) {

                byte[] vbytes = longToByteArray(v, 4);

                putNumber(vbytes);

    }

        public void putShort(short v) {

                byte[] vbytes = longToByteArray(v, 2);

                putNumber(vbytes);

    }

        private static byte[] longToByteArray(long v, int size) {

                byte[] resp = new byte[size];

                long aux = v;

                for (int i=0; i<size; i++) {

                        resp[size - 1 - i] = (byte) (0xff & aux);

                        aux >>= 8;

                }

                return resp;

        }

        public byte get(int ind) {

                if (ind >= bytes.length) {

                        logger.error("Index too large: " + ind + ". Returned zero.");

                        return 0;

                } else {

                        return bytes[ind];

                }

        }

        public short getShort() {

                short resp = getShort(bytes, pos);

                pos = pos + 2;

                return resp;

        }

        public int getInt(int index) {

                int resp = getInt(bytes, index);

                return resp;

        }

        public byte[] getAllBytes() {

                return bytes;

        }

}