Application: gvSIG desktop » gvSIG raster

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

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

import org.gvsig.raster.lib.buffer.api.exceptions.BandException;

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;

/**

 * @author fdiaz

 *

 */

public abstract class AbstractBand extends BaseWeakReferencingObservable implements Band {

    protected static final Logger logger = LoggerFactory.getLogger(AbstractBand.class);

    int rows;

    int columns;

    NoData noData;

    // to make it disposable

    private final Object lock = new Object();

    private boolean disposed = false;

    public AbstractBand() {

        if(ToolsLocator.getDisposableManager() != null) {

            ToolsLocator.getDisposableManager().bind(this);

        } else {

            logger.warn("Can't retrieve the disposable manager,");

        }

    }

    @Override

    public int getColumns() {

        return columns;

    }

    @Override

    public int getRows() {

        return rows;

    }

    @Override

    public NoData getNoData() {

        return this.noData;

    }

    @Override

    public BandInfo getBandInfo() {

        return null;

    }

    public Object clone() throws CloneNotSupportedException {

        AbstractBand cloned = (AbstractBand) super.clone();

        cloned.rows = this.rows;

        cloned.columns = this.columns;

        cloned.noData = (NoData) this.noData.clone();

        try {

            cloned.copyFrom(this);

        } catch (BandException e) {

            throw new CloneNotSupportedException(e.getMessage());

        }

        return cloned;

    }

    @Override

    public boolean isReadOnly() {

        return false;

    }

    @Override

    public boolean isPaginated() {

        return false;

    }

    public void set(int row, int column, Object value){

        doSet(row, column, value);

        notifyObservers(new DefaultBandNotification(BandNotification.SET, new Object[]{row, column, value}));

    }

    protected abstract void doSet(int row, int column, Object value);

    @Override

    public void fill(Object value) {

        doFill(value);

        notifyObservers(new DefaultBandNotification(BandNotification.FILL, new Object[]{value}));

    }

    protected abstract void doFill(Object value);

    /**

     * @param value NoData value

     * @return

     */

    protected Object nullValueToNoData(Object value) {

        if (value == null) {

            if (getNoData().isDefined()) {

                value = getNoData().getValue();

            } else {

                // Do nothing, no data value is undefined

                return null;

            }

        }

        return value;

    }

    @Override

    public void copyFrom(Band source) throws BandException {

        doCopyFrom(source);

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

    }

    protected abstract void doCopyFrom(Band source) throws CopyFromBandException;

    @Override

    public void copyFrom(Band source, int row, int column) throws BandException {

        doCopyFrom(source, row, column);

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

    }

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

    @Override

    public void putRow(int row, Object rowBuffer) {

        doPutRow(row, rowBuffer);

        notifyObservers(new DefaultBandNotification(BandNotification.PUT_ROW, new Object[]{row, rowBuffer}));

    }

    protected abstract void doPutRow(int row, Object rowBuffer);

    @Override

    protected void finalize() throws Throwable {

        super.finalize();

    }

    public final void dispose() {

        synchronized (lock) {

            // Check if we have already been disposed, and don't do it again

            if (!disposed) {

                if ( ToolsLocator.getDisposableManager().release(this) ) {

                    try {

                        doDispose();

                    } catch (BaseException ex) {

                        logger.error("Error performing dispose", ex);

                    }

                    disposed = true;

                }

            }

        }

    }

    /**

     * Internal implementation for the {@link #dispose()} method.

     *

     * @see #dispose()

     */

    public void doDispose() throws BaseException {

        noData = null;

    }

}