Application: gvSIG desktop

package org.gvsig.raster.lib.buffer.impl;

import java.io.IOException;

import java.nio.Buffer;

import org.gvsig.raster.lib.buffer.api.Band;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.BandNotification;

import org.gvsig.raster.lib.buffer.api.BandTileManager;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.impl.exceptions.CopyFromBandException;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.exception.BaseException;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractTiledBand extends AbstractBand implements Band {

    protected Buffer data; //data loaded

    protected int firstRowOfTile;

    protected int firstColumnOfTile;

    protected int rowsPerTile;

    protected int columnsPerTile;

    protected BandTileManager tileManager;

    private boolean loaded;

    protected int rowsInTile;

    protected int columnsInTile;

    /**

     * @param rows

     * @param columns

     * @param noData

     * @param tileManager

     */

    public AbstractTiledBand(int rows, int columns, NoData noData, BandTileManager tileManager) {

        this.rows = rows;

        this.columns = columns;

        this.loaded=false;

        this.rowsPerTile=tileManager.getRowsPerTile();

        this.columnsPerTile=tileManager.getColumnsPerTile();

        this.rowsInTile=rowsPerTile;

        this.columnsInTile=columnsPerTile;

        if (noData == null) {

            this.noData = BufferLocator.getBufferManager().createNoData(null, null);

        } else {

            this.noData = noData;

        }

        this.tileManager = tileManager;

    }

    @Override

    protected void doCopyFrom(Band source) throws CopyFromBandException {

        if (this.getColumns() != source.getColumns() || this.getRows() != source.getRows()

            || this.getDataType()!=source.getDataType() ) {

            throw new CopyFromBandException(source, this);

        }

        Object rowBuffer = this.createRowBuffer();

        for(int row = 0; row<=this.rows; row++){

            source.fetchRow(row, rowBuffer);

            this.putRow(row, rowBuffer);

        }

    }

    @Override

    protected void doCopyFrom(Band source, int row, int column) throws CopyFromBandException {

        if (this.getColumns() <= row+source.getColumns() || this.getRows() <= column+source.getRows()

            || this.getDataType()!=source.getDataType() ) {

            throw new CopyFromBandException(source, this);

        }

        //FIXME:

        Object rowBuffer = source.createRowBuffer();

        for(int r=0; r<Math.min(this.getRows()-row, source.getRows()); r++){

            source.fetchRow(r, rowBuffer);

            System.arraycopy(rowBuffer, 0, this.data, (r+row)*this.getColumns()+column, Math.min(this.getColumns()-column, source.getColumns()));

            this.putRow(r, rowBuffer);

        }

    }

    protected void loadTile(int row, int column) {

        //The tile to be loaded must be inside the band's limits

        if (loaded &&

            row >= firstRowOfTile &&

            row < firstRowOfTile + rowsPerTile &&

            column >= firstColumnOfTile &&

            column < firstColumnOfTile + columnsPerTile

            ) {

            return;

        }

        if(loaded) {

            saveCurrentTile();

        }

        loaded=false;

        int currentTileRow = row / rowsPerTile; //Divisi?n entera

        firstRowOfTile = currentTileRow * rowsPerTile;

        int currentTileColumn = column / columnsPerTile; //Divisi?n entera

        firstColumnOfTile = currentTileColumn * columnsPerTile;

        Band loadedBand = null;

        try {

            rowsInTile = rowsPerTile;

            if(firstRowOfTile + rowsPerTile > this.rows){

                rowsInTile = this.rows - firstRowOfTile;

            }

            columnsInTile = columnsPerTile;

            if(firstColumnOfTile + columnsPerTile > this.columns){

                columnsInTile = this.columns - firstColumnOfTile;

            }

            loadedBand = this.tileManager.load(firstRowOfTile,

                firstColumnOfTile,

                this.getDataType());

//            DisposeUtils.bind(loadedBand);

            Object rowBuffer = loadedBand.createRowBuffer();

            //TODO: for development time only. Remove after.

            /*

            logger.info("---------------------------------- ");

            logger.info("row = "+row+" column = "+column);

            logger.info("loadedBand.getRows() = " + loadedBand.getRows());

            logger.info("loadedBand.getColumns() = " + loadedBand.getColumns());

            logger.info("rowsInTile = " + rowsInTile);

            logger.info("columnsInTile = " + columnsInTile);

            logger.info("rowsPerTile = " + rowsPerTile);

            logger.info("columnsPerTile = " + columnsPerTile);

            logger.info("firstRowOfTile = " + firstRowOfTile);

            logger.info("firstColumnOfTile = " + firstColumnOfTile);

            logger.info("data.capacity() = " + data.capacity());

            */

            for (int loadedRow = 0; loadedRow < rowsInTile; loadedRow++) { //< loadedBand.getRows()

                loadedBand.fetchRow(loadedRow, rowBuffer);

                int pos = loadedRow * columnsInTile; //loadedBand.getColumns();

                //TODO: for development time only. Remove after.

                /*

                if(pos >= data.limit()){

                  logger.info("Posible error copiando el array: pos = " + pos+ " limit = "+data.limit());

                  continue;

                }

                */

                System.arraycopy(rowBuffer, 0, data.array(), pos, loadedBand.getColumns());

            }

//            logger.info("---------------------------------- ");

            loaded=true;

            this.notifyObservers(new DefaultBufferNotification(BandNotification.LOADED_PAGE, new Object[] { this }));

        } catch (IOException e) {

            throw new RuntimeException("Can't load current tile", e);

        } finally {

            DisposeUtils.dispose(loadedBand);

        }

    }

    protected void saveCurrentTile() {

        try {

            int rowsInTile = rowsPerTile;

            if(firstRowOfTile + rowsPerTile > this.rows){

                rowsInTile = this.rows - firstRowOfTile;

            }

            int columnsInTile = columnsPerTile;

            if(firstColumnOfTile + columnsPerTile > this.columns){

                columnsInTile = this.columns - firstColumnOfTile;

            }

            this.tileManager.save(data,

                firstRowOfTile, rowsInTile,

                firstColumnOfTile, columnsInTile,

                this.getDataType());

        } catch (UnsupportedOperationException e) {

            // Do nothing, operation not supported

        } catch (IOException e) {

            throw new RuntimeException("Can't save current tile", e);

        }

    }

    protected abstract int getDataSize();

    @Override

    public boolean isReadOnly() {

        if(this.tileManager==null){

            return false;

        }

        return !this.tileManager.isSupportedSave();

    }

    @Override

    public boolean isPaginated() {

        //FIXME: ?????

        return true;

    }

    @Override

    public BandInfo getBandInfo() {

        return this.tileManager == null ? null : this.tileManager.getBandInfo();

    }

    /**

     * Calculate buffer size than must be allocated.

     * @param rows

     * @param columns

     * @return

     */

    protected int calculateBufferSizeToAllocate(int rows, int columns){

        // If the number of requested cells is less than the default number of

        // cells, it is unnecessary to reserve the maximum possible size.

        int allocateRows = rowsInTile;

        if(rows<rowsInTile){

            allocateRows = rows;

        }

        int allocateColumns = columnsInTile;

        //FIXME: Comprobar si se puede utilizar la condici?n de abajo antes de descomentarizarla

//        if(columns<columnsInTile){

//            allocateColumns = columns;

//        }

        return allocateRows*allocateColumns;

    }

    @Override

    public void doDispose() throws BaseException {

        super.doDispose();

        data = null;

        //FIXME: ?hacer disposables los pageManagers?

        tileManager = null;

    }

}