| gvSIG desktop 1

/* 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) {

                // logger.debug("Instanciamos ByteBufferJME con tamanyo: " + System.currentTimeMillis());

                bytes = new byte[size];

        }

        public ByteBufferJME(byte[] bb) {

                // logger.debug("Instanciamos ByteBufferJME con array : " + System.currentTimeMillis());

                bytes = bb;

        }

//        /**

//         * Constructor

//         * @param bb array of bytes to be stored

//         */

//        public ByteBufferJME(byte[] bb) {

//                bytes = bb;

//        }

//        

//        /**

//         * Moves file cursor to position p 

//         * @param p the new position

//         */

//        public void position(int p) {

//                pos = p;

//        }

//        

//        /**

//         * 

//         * @return current cursor position

//         */

//        public int getPosition() {

//                return pos;

//        }

//        

//        /**

//         * @return byte pointed by cursor then increases cursor

//         */

//        public byte getByte() {

//                byte resp = bytes[pos];

//                pos++;

//                return resp;

//        }

//        

//        /**

//         * Gets one byte

//         * @param ind index of the byte of interest 

//         * @return the byte of interest

//         */

//        public byte getByte(int ind) {

//                return bytes[ind];

//        }

//

//        /**

//         * @return integer pointed by cursor then increases cursor

//         */

//        public int getInt() {

//                int resp = getInt(bytes, pos);

//                pos = pos + 4;

//                return resp;

//        }

//        

//        /**

//         * @return short pointed by cursor then increases cursor

//         */

//        public short getShort() {

//                short resp = getShort(bytes, pos);

//                pos = pos + 2;

//                return resp;

//        }

//        

//        /**

//         * Gets the integer at a certain position

//         * @param index the index of interest

//         * @return the integer at a certain position

//         */

//        public int getInt(int index) {

//                int resp = getInt(bytes, index);

//                return resp;

//        }

//        

//        /**

//         * Gets some bytes.

//         * @param out the array of bytes to be filled

//         */

//        public void getBytes(byte[] out) {

//                for (int i=0; i<out.length; i++) {

//                        out[i] = getByte(pos + i);

//                }

//                pos = pos + out.length;

//        }

//        

//        /**

//         * @return double pointed by cursor then increases cursor

//         */

//        public double getDouble() {

//                double resp = getDouble(bytes, pos);

//                pos = pos + 8;

//                return resp;

//        }

//        

//        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);

//    }

//

//        

//        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 double getDouble(final byte[] data, final int offset) {

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

//    }

//

//        /**

//         * Sets byte order (big endian, little endian)

//         * @param o byte order (big endian, little endian)

//         */

//        public void setByteOrder(ByteOrder o) {

//                byteOrder = o;

//        }

        public void get(byte[] out) {

                // logger.debug("ByteBufferJME, get : " + System.currentTimeMillis());

                int canread = bytes.length - pos;

//                if (canread < out.length) {

//                        logger.warn("output buffer too long. Cannot read all " + out.length + " bytes.");

//                }

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

                // logger.debug("ByteBufferJME, get, array copy: " + System.currentTimeMillis());

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

                // logger.debug("ByteBufferJME, get, array copy, done: " + System.currentTimeMillis());

                pos = pos + canread;

        }

        public void put(byte[] input) {

                // logger.debug("ByteBufferJME, put : " + System.currentTimeMillis());

                int canwrite = bytes.length - pos;

                if (canwrite < input.length) {

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

                        return;

                }

                // logger.debug("ByteBufferJME, put, array copy : " + System.currentTimeMillis());

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

                // logger.debug("ByteBufferJME, put array copy, done : " + System.currentTimeMillis());

                pos = pos + input.length;

        }

        public IByteBuffer flip() {

                // logger.debug("ByteBufferJME, flip : " + System.currentTimeMillis());

                byte[] newbytes = new byte[pos];

                // logger.debug("ByteBufferJME, flip, array bytes : " + System.currentTimeMillis());

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

                // logger.debug("ByteBufferJME, flip, array bytes, done : " + System.currentTimeMillis());

                bytes = newbytes;

                pos = 0;

                return this;

        }

        public void order(ByteOrder o) {

                byteOrder = o;

        }

        public void put(byte b) {

                // logger.debug("ByteBufferJME, put byte : " + System.currentTimeMillis());

                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 void get(byte[] bb, int pos, int length) {

//        }

        public ByteOrder order() {

                return byteOrder;

        }

        public byte get() {

                // logger.debug("ByteBufferJME, get byte : " + System.currentTimeMillis());

                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 double getDouble(int offset) {

//                return getDouble(bytes, offset);

//        }

        public int capacity() {

                return bytes.length;

        }

        public IByteBuffer limit(int newlimit) {

                // logger.debug("ByteBufferJME, limit (" + newlimit + ") : " + System.currentTimeMillis());

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

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

                        return this;

                }

                byte[] newbytes = new byte[newlimit];

                // logger.debug("ByteBufferJME, limit, array copy  : " + System.currentTimeMillis());

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

                // logger.debug("ByteBufferJME, limit, array copy, done  : " + System.currentTimeMillis());

                bytes = newbytes;

                if (pos > newlimit) {

                        pos = newlimit;

                }

                return this;

        }

        public int limit() {

                return bytes.length;

        }

        public void position(int newp) {

                // logger.debug("ByteBuffer JME Vamos a la posicion " + newp);

                pos = newp;

        }

        public double getDouble() {

                // logger.debug("ByteBufferJME, get Double  : " + System.currentTimeMillis());

                double resp = getDouble(bytes, pos);

                pos = pos + 8;

                return resp;

        }

        public int getInt() {

                // logger.debug("ByteBufferJME, get Int  : " + System.currentTimeMillis());

                int resp = getInt(bytes, pos);

                pos = pos + 4;

                return resp;

        }

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

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

                // logger.debug("ByteBufferJME, get Number  : " + System.currentTimeMillis());

        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) {

                // logger.debug("ByteBufferJME, put Number  : " + System.currentTimeMillis());

        if (byteOrder == ByteOrder.LITTLE_ENDIAN) {

                byte[] reversed = reverse(number);

                put(reversed);

        } else {

                put(number);

        }

    }

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

                // logger.debug("ByteBufferJME, reverse  : " + System.currentTimeMillis());

                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) {

                // logger.debug("ByteBufferJME, getDouble, two params  : " + System.currentTimeMillis());

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

    }

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

                // logger.debug("ByteBufferJME, getInt, two params  : " + System.currentTimeMillis());

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

    }

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

                // logger.debug("ByteBufferJME, getShort, two params  : " + System.currentTimeMillis());

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

    }

        public void putDouble(double v) {

                // logger.debug("ByteBufferJME, putDouble  : " + System.currentTimeMillis());

                long vlong = Double.doubleToLongBits(v);

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

                putNumber(vbytes);

    }

        public void putInt(int v) {

                // logger.debug("ByteBufferJME, putInt  : " + System.currentTimeMillis());

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

                putNumber(vbytes);

    }

        public void putShort(short v) {

                // logger.debug("ByteBufferJME, putShort  : " + System.currentTimeMillis());

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

                putNumber(vbytes);

    }

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

                // logger.debug("ByteBufferJME, longToByteArray, two params  : " + System.currentTimeMillis());

                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) {

                // logger.debug("ByteBufferJME, get : " + System.currentTimeMillis());

                if (ind >= bytes.length) {

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

                        return 0;

                } else {

                        return bytes[ind];

                }

        }

        public short getShort() {

                // logger.debug("ByteBufferJME, getShort : " + System.currentTimeMillis());

                short resp = getShort(bytes, pos);

                pos = pos + 2;

                return resp;

        }

        public int getInt(int index) {

                // logger.debug("ByteBufferJME, getint : " + System.currentTimeMillis());

                int resp = getInt(bytes, index);

                return resp;

        }

        public byte[] getAllBytes() {

                // logger.debug("ByteBufferJME, getAllBytes : " + System.currentTimeMillis());

                return bytes;

        }

}