Application: gvSIG desktop

package org.gvsig.datasources.impljme;

import java.io.IOException;

import java.nio.ByteOrder;

import org.apache.log4j.Logger;

import org.gvsig.datasources.common.IBigByteBuffer;

import org.gvsig.datasources.common.IByteBuffer;

import org.gvsig.datasources.common.IRandomFileChannel;

/**

 * This class implements the IBigByteBuffer for JME. As the desktop version,

 * it keeps a small buffer in memory, by using the classes ByteBufferJME

 * and RandomFileChannelJME.

 *

 * @see org.gvsig.datasources.impljme.ByteBufferJME

 * @see org.gvsig.datasources.impljme.RandomFileChannelJME

 *

 * @author jldominguez

 *

 */

public class BufferedBigByteBufferJME implements IBigByteBuffer {

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

        /**

         * Memory buffer size

         */

        public static long DEFAULT_SIZE = 4*1024; // 8 Kbytes

        private ByteBufferJME theBuffer = null;

    private RandomFileChannelJME fc;

    private long minAbs, maxAbs, posAbs;

    private int minRel,  maxRel, posRel;

    private long sizeChunk, amountMem;

    private long fileSize;

    private int mode;

    public BufferedBigByteBufferJME(IRandomFileChannel ch, int acc_mode) {

        amountMem = DEFAULT_SIZE;

        fc = (RandomFileChannelJME) ch;

        try {

                        fileSize = fc.size();

                mode = acc_mode;

                sizeChunk = Math.min(fc.size(), amountMem);

                } catch (IOException e) {

                        logger.error("While instantiating: " + e.getMessage());

                }

        theBuffer = (ByteBufferJME) Impl.allocateDirect((int) sizeChunk);

        byte[] aux = new byte[(int) sizeChunk];

        fc.getAsIs(aux);

        theBuffer.put(aux);

        theBuffer.position(0);

        minAbs = 0;

        maxAbs = sizeChunk;

    }

    /**

     * Checks the position and loads the data if necessary.

     *

     * @throws IOException

     */

    private void prepareBuffer(long posActual, int numBytesToRead)

    {

        long desiredPos = posActual + numBytesToRead;

        if ((desiredPos > maxAbs) || (posActual < minAbs)) {

                // logger.debug("Se ha pedido fuera del buffer: Tenemos: ["

                //                 + minAbs + " , "  + maxAbs + "], Se pide hasta: " + desiredPos);

            // Quiero leer fuera:

            sizeChunk = Math.min(fileSize-posActual, amountMem);

            try {

                mapFrom(posActual);

            } catch (IOException e) {

                e.printStackTrace();

            }

        } else {

                theBuffer.position((int) (posActual - minAbs));

                // System.out.println("NOT setting in buffer");

        }

        // Dejamos posAbs apuntando a donde va a quedar

        // "a priori", antes de leer de verdad, que se hace

        // al salir de esta funci?n.

        posAbs = desiredPos;

    }

    /**

     * @param posActual

     * @throws IOException

     */

    private IByteBuffer mapFrom(long newPos) throws IOException {

        ByteOrder lastOrder = theBuffer.order();

        // bb = fc.map(mode, newPos, sizeChunk);

        fc.position((int) newPos);

        // bb = ByteBuffer.wrap(buff);

        // bb = ByteBuffer.allocate((int)sizeChunk);

        theBuffer.position(0);

        byte[] newbuf = new byte[(int) sizeChunk];

        fc.getAsIs(newbuf);

        theBuffer = new ByteBufferJME(newbuf);

        // System.out.println("Mapeo desde " + newPos + " con sizeChunk= " + sizeChunk + " numRead = " + numRead);

        minAbs = newPos;

        maxAbs = sizeChunk + newPos;

        theBuffer.order(lastOrder);

        return theBuffer;

    }

        public void position(long p) {

        prepareBuffer(p, 0);

        int relPos = (int) (p - minAbs);

        if (relPos < 0) {

            System.out.println("Position=" + p);

        }

        }

        public int position() {

                // TODO Auto-generated method stub

                return (int) posAbs;

        }

        public byte get() {

        prepareBuffer(posAbs, 1);

        return theBuffer.get();

        }

        public byte getByte(int ind) {

        prepareBuffer(ind, 1);

        return theBuffer.get(ind - (int) minAbs);

        }

        public int getInt() {

        prepareBuffer(posAbs, 4);

        return theBuffer.getInt();

        }

        public short getShort() {

        prepareBuffer(posAbs, 2);

        return theBuffer.getShort();

        }

        public int getInt(int index) {

        prepareBuffer(index, 4);

        return theBuffer.getInt(index - (int) minAbs);

        }

        public void get(byte[] out) {

        prepareBuffer(posAbs, out.length);

        theBuffer.get(out);

        }

        public double getDouble() {

        prepareBuffer(posAbs, 8);

        return theBuffer.getDouble();

        }

        public void order(ByteOrder o) {

                theBuffer.order(o);

        }

}