Application: gvSIG desktop

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

import java.io.IOException;

import java.nio.Buffer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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.BandPageManager;

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

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

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 AbstractPaginatedBand extends AbstractBand implements Band {

    private static final Logger logger = LoggerFactory.getLogger(AbstractPaginatedBand.class);

    protected Buffer data;

    protected int firstRowOfPage;

    protected int rowsPerPage;

    protected BandPageManager pageManager;

    private boolean loaded;

    // protected static final int MAX_PREFERED_SIZE = 10485760; // 10MB;

    protected static final int MAX_PREFERED_SIZE = 2621440; // 2.5MB;

    /**

     * @param rows

     * @param columns

     * @param noData

     * @param pageManager

     */

    public AbstractPaginatedBand(int rows, int columns, NoData noData, BandPageManager pageManager) {

        this.rows = rows;

        this.columns = columns;

        this.loaded = false;

        calculateRowsPerPage();

        if (noData == null) {

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

        } else {

            this.noData = noData;

        }

        this.pageManager = pageManager;

        DisposeUtils.bind(pageManager);

    }

    private void calculateRowsPerPage() {

        rowsPerPage = MAX_PREFERED_SIZE / (this.columns * getDataSize());

        if (rowsPerPage < 1) {

            rowsPerPage = 1;

        }

        if (rowsPerPage > rows) {

            rowsPerPage = rows;

        }

    }

    @Override

    public void copyFrom(Band source) throws CopyFromBandException {

        doCopyFrom(source);

        notifyObservers(new DefaultBandNotification(BandNotification.COPY_FROM, new Object[] { source }));

    }

    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 loadPage(int row) {

        if (loaded && row >= firstRowOfPage && row < firstRowOfPage + rowsPerPage) {

            return;

        }

        loaded = false;

        saveCurrentPage();

        int currentPage = row / rowsPerPage; // Divisi?n entera

        firstRowOfPage = currentPage * rowsPerPage;

        try {

            int rowsInPage = rowsPerPage;

            if (firstRowOfPage + rowsPerPage > this.rows) {

                rowsInPage = this.rows - firstRowOfPage;

            }

            this.pageManager.load(data, firstRowOfPage, rowsInPage, this.getDataType());

            loaded = true;

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

        } catch (IOException e) {

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

        }

    }

    protected void saveCurrentPage() {

        try {

            int rowsInPage = rowsPerPage;

            if (firstRowOfPage + rowsPerPage > this.rows) {

                rowsInPage = this.rows - firstRowOfPage;

            }

            this.pageManager.save(data, firstRowOfPage, rowsInPage, this.getDataType());

        } catch (UnsupportedOperationException e) {

            // Do nothing, operation not supported

        } catch (IOException e) {

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

        }

    }

    protected abstract int getDataSize();

    @Override

    public boolean isReadOnly() {

        if (this.pageManager == null) {

            return false;

        }

        return !this.pageManager.isSupportedSave();

    }

    @Override

    public boolean isPaginated() {

        return true;

    }

    @Override

    public BandInfo getBandInfo() {

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

    }

    /**

     * Calculate buffer size than must be allocated.

     *

     * @param rows

     * @param columns

     * @return

     */

    protected int calculateBufferSizeToAllocate(int rows, int columns) {

        return rowsPerPage * columns;

    }

    @Override

    public void doDispose() throws BaseException {

        super.doDispose();

        data = null;

        DisposeUtils.dispose(pageManager);

        pageManager = null;

    }

    @Override

    protected void finalize() throws Throwable {

        super.finalize();

    }

}