Application: gvSIG desktop

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 gvSIG Association

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.raster.impl;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.Set;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.BaseStoresRepository;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataQuery;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataSet;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.DataStoreProviderFactory;

import org.gvsig.fmap.dal.StoresRepository;

import org.gvsig.fmap.dal.exception.CloneException;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.feature.exception.PersistenceStoreAlreadyLoadedException;

import org.gvsig.fmap.dal.impl.DefaultDataManager;

import org.gvsig.fmap.dal.raster.RasterStoreProviderFactory;

import org.gvsig.fmap.dal.raster.BandAttributeDescriptor;

import org.gvsig.fmap.dal.raster.BandDescriptor;

import org.gvsig.fmap.dal.raster.BandQuery;

import org.gvsig.fmap.dal.raster.RasterCache;

import org.gvsig.fmap.dal.raster.RasterQuery;

import org.gvsig.fmap.dal.raster.RasterSet;

import org.gvsig.fmap.dal.raster.RasterStore;

import org.gvsig.fmap.dal.raster.RasterStoreNotification;

import org.gvsig.fmap.dal.raster.exceptions.RasterQueryCloneException;

import org.gvsig.fmap.dal.raster.impl.exceptions.AddingBandsException;

import org.gvsig.fmap.dal.raster.spi.RasterCacheStoreProvider;

import org.gvsig.fmap.dal.raster.spi.RasterStoreProvider;

import org.gvsig.fmap.dal.raster.spi.RasterStoreProviderServices;

import org.gvsig.fmap.dal.resource.Resource;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.spi.DALSPILocator;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreInitializer2;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

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

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

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

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

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynObject_v2;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.dynobject.exception.DynMethodException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.observer.Observable;

import org.gvsig.tools.observer.Observer;

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

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.resourcesstorage.ResourcesStorage;

import org.gvsig.tools.util.UnmodifiableBasicMap;

import org.gvsig.tools.visitor.Visitor;

/**

 * Implements RasterStore

 *

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultRasterStore extends AbstractDisposable implements DataStoreInitializer2,

    RasterStoreProviderServices, RasterStore, Observer {

    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultRasterStore.class);

    private static final String PERSISTENCE_DEFINITION_NAME = "RasterStore";

    private static final String METADATA_DEFINITION_NAME = "RasterStore";

    private DataStoreParameters parameters = null;

    private RasterStoreProvider provider = null;

    private DelegatedDynObject metadata;

    private DefaultDataManager dataManager = null;

    private List<BandsFromStore> additionalBands = null;

    private DelegateWeakReferencingObservable delegateObservable = new DelegateWeakReferencingObservable(this);

    /**

     * Registers persistence

     */

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if (manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null) {

            DynStruct definition =

                manager.addDefinition(DefaultRasterStore.class, PERSISTENCE_DEFINITION_NAME,

                    PERSISTENCE_DEFINITION_NAME + " Persistent definition", null, null);

            definition.addDynFieldString("dataStoreName").setMandatory(true).setPersistent(true);

            definition.addDynFieldObject("parameters").setClassOfValue(DynObject.class).setMandatory(true)

                .setPersistent(true);

        }

    }

    /**

     * Registers metadata

     *

     * @throws MetadataException

     */

    public static void registerMetadataDefinition() throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            DynStruct metadataDefinition = manager.addDefinition(METADATA_DEFINITION_NAME, null);

            metadataDefinition.extend(manager.getDefinition(DataStore.METADATA_DEFINITION_NAME));

        }

    }

    /**

     * @return dataManager

     */

    @Override

    public DataManager getManager() {

        return this.dataManager;

    }

    @Override

    public String getName() {

        return this.provider.getName();

    }

    @Override

    public String getFullName() {

        return this.provider.getFullName();

    }

    @Override

    public DataStoreParameters getParameters() {

        return parameters;

    }

    @Override

    public String getProviderName() {

        return this.provider.getProviderName();

    }

    @Override

    public void refresh() throws DataException {

        this.notifyChange(RasterStoreNotification.BEFORE_REFRESH);

        this.provider.refresh();

        this.notifyChange(RasterStoreNotification.AFTER_REFRESH);

    }

    @Override

    public DataSet getDataSet() throws DataException {

        return this.getRasterSet();

    }

    @Override

    public DataSet getDataSet(DataQuery dataQuery) throws DataException {

        return this.getRasterSet((RasterQuery) dataQuery);

    }

    @Override

    public void getDataSet(Observer observer) throws DataException {

        this.getRasterSet(null, observer);

    }

    @Override

    public void getDataSet(DataQuery dataQuery, Observer observer) throws DataException {

        this.getRasterSet((RasterQuery) dataQuery, observer);

    }

    @Override

    public RasterSet getRasterSet(RasterQuery rasterQuery) throws DataException {

        try {

            if (rasterQuery != null) {

                List<BandQuery> queryBands = rasterQuery.getBands();

                if (!queryBands.isEmpty()) {

                    RasterQuery mainRasterQuery = (RasterQuery) rasterQuery.clone();

                    mainRasterQuery.clearBands();

                    Map<RasterStore, RasterQuery> rasterQueries = new HashMap<>();

                    for (BandQuery bandQuery : queryBands) {

                        int band = bandQuery.getBand();

                        if(band<getProvider().getBands()){

                            mainRasterQuery.addBand(bandQuery);

                        } else {

                            int bandCounter = getProvider().getBands();

                            boolean bandFound = false;

                            if(additionalBands!=null){

                                for (BandsFromStore bandsFromStore : additionalBands) {

                                    RasterStore store = bandsFromStore.getStore();

                                    if (band < bandCounter + bandsFromStore.size()) {

                                        BandQuery storeBandQuery =

                                            store.createBandQuery(bandsFromStore.get(band - bandCounter));

                                        if (rasterQueries.containsKey(store)) {

                                            rasterQueries.get(store).addBand(storeBandQuery);

                                        } else {

                                            RasterQuery storeRasterQuery = (RasterQuery) rasterQuery.clone();

                                            storeRasterQuery.clearBands();

                                            storeRasterQuery.addBand(storeBandQuery);

                                            rasterQueries.put(store, storeRasterQuery);

                                            bandFound = true;

                                        }

                                    }

                                    bandCounter += bandsFromStore.size();

                                    if (bandFound) {

                                        break;

                                    }

                                }

                            }

                        }

                    }

                    RasterSet mainRasterSet = new DefaultRasterSet(this, mainRasterQuery);

                    for (Entry<RasterStore, RasterQuery> entry : rasterQueries.entrySet()) {

                        RasterStore store = entry.getKey();

                        RasterQuery query = entry.getValue();

                        RasterSet subRasterSet = store.getRasterSet(query);

                        for (Band band : subRasterSet) {

                            mainRasterSet.addBand(band);

                        }

                    }

                    return mainRasterSet;

                }

            }

            RasterSet mainRasterSet = new DefaultRasterSet(this, rasterQuery);

            if (additionalBands != null) {

                for (BandsFromStore bandsFromStore : additionalBands) {

                    RasterStore store = bandsFromStore.getStore();

                    RasterQuery subRasterQuery = store.createRasterQuery();

                    if( rasterQuery!=null ) {

                      subRasterQuery.setClip(rasterQuery.getClip());

                      subRasterQuery.setScale(rasterQuery.getScale());

                    }

                    subRasterQuery.setPixelSize(mainRasterSet.getDimensions().getPixelSizeX());

                    for (int i = 0; i < bandsFromStore.size(); i++) {

                        BandQuery bandQuery = store.createBandQuery(bandsFromStore.get(i));

                        subRasterQuery.addBand(bandQuery);

                    }

                    DefaultRasterSet subRasterSet = new DefaultRasterSet(store, subRasterQuery);

                    if(subRasterSet.getColumns()!=mainRasterSet.getColumns() || subRasterSet.getRows()!=mainRasterSet.getRows()){

                        Buffer subBuffer = subRasterSet.createInterpolated(mainRasterSet.getRows(), mainRasterSet.getColumns(), Buffer.INTERPOLATION_NearestNeighbour, null);

                        for (Band band : subBuffer) {

                            mainRasterSet.addBand(band);

                        }

                    } else {

                        for (Band band : subRasterSet) {

                            mainRasterSet.addBand(band);

                        }

                    }

                    DisposeUtils.disposeQuietly(subRasterSet);

                }

            }

            return mainRasterSet;

        } catch (Exception e) {

            throw new RasterQueryCloneException(e);

        }

    }

    @Override

    public RasterSet getRasterSet() throws DataException {

        return getRasterSet(createRasterQuery());

    }

    /**

     * Adds an observer to the DataSet

     *

     * @param observer

     * @throws DataException

     */

    @Override

    public void getRasterSet(Observer observer) throws DataException {

        RasterSet set = this.getRasterSet();

        set.addObserver(observer);

    }

    /**

     * Adds an observer to the queried DataSet

     *

     * @param rasterQuery

     * @param observer

     * @throws DataException

     */

    @Override

    public void getRasterSet(RasterQuery rasterQuery, Observer observer) throws DataException {

        RasterSet set = this.getRasterSet(rasterQuery);

        set.addObserver(observer);

    }

    @Override

    public void accept(Visitor visitor) throws BaseException {

        RasterSet set = getRasterSet();

        try {

            set.accept(visitor);

        } finally {

            set.dispose();

        }

    }

    @Override

    public void accept(Visitor visitor, DataQuery dataQuery) throws BaseException {

        RasterSet set = getRasterSet((RasterQuery) dataQuery);

        try {

            set.accept(visitor);

        } finally {

            set.dispose();

        }

    }

    @Override

    public DataSet getSelection() throws DataException {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public void setSelection(DataSet selection) throws DataException {

        // TODO Auto-generated method stub

    }

    @Override

    public DataSet createSelection() throws DataException {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public UnmodifiableBasicMap<String,DataStore> getChildren() {

        UnmodifiableBasicMap<String, DataStore> children = this.provider.getChildren();

        if( children == null ) {

            return UnmodifiableBasicMap.EMPTY_UNMODIFIABLEBASICMAP;

        }

        return children;

    }

    @Override

    public DataServerExplorer getExplorer() throws DataException, ValidateDataParametersException {

        return this.provider.getExplorer();

    }

    @Override

    public DataQuery createQuery() {

        return createRasterQuery();

    }

    @Override

    public Interval getInterval() {

        return this.provider.getInterval();

    }

    @Override

    public Collection<?> getTimes() {

        return this.provider.getTimes();

    }

    @Override

    public Collection<?> getTimes(Interval interval) {

        return this.provider.getTimes(interval);

    }

    @Override

    public void disableNotifications() {

        this.delegateObservable.disableNotifications();

    }

    @Override

    public void enableNotifications() {

        this.delegateObservable.enableNotifications();

    }

    @Override

    public void beginComplexNotification() {

        this.delegateObservable.beginComplexNotification();

    }

    @Override

    public void endComplexNotification() {

        this.delegateObservable.endComplexNotification();

    }

    @Override

    public void addObserver(Observer observer) {

        if (delegateObservable != null) {

            this.delegateObservable.addObserver(observer);

        }

    }

    @Override

    public void deleteObserver(Observer observer) {

        if (delegateObservable != null) {

            this.delegateObservable.deleteObserver(observer);

        }

    }

    @Override

    public void deleteObservers() {

        this.delegateObservable.deleteObservers();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("dataStoreName", this.getName());

        state.set("parameters", this.parameters);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        if (this.provider != null) {

            throw new PersistenceStoreAlreadyLoadedException(this.getName());

        }

        if (this.getManager() == null) {

            this.dataManager = (DefaultDataManager) DALLocator.getDataManager();

        }

        DataStoreParameters params = (DataStoreParameters) state.get("parameters");

        try {

            this.intialize(this.dataManager, params);

            this.setProvider(this.provider);

        } catch (Exception e) {

            throw new PersistenceException(e);

        }

    }

    //

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

    // Metadata related methods

    //

    @Override

    public Set<?> getMetadataChildren() throws MetadataException {

        // TODO Auto-generated method stub

        return null;

    }

    @Override

    public Object getMetadataID() throws MetadataException {

        return this.provider.getSourceId();

    }

    @Override

    public String getMetadataName() throws MetadataException {

        return this.provider.getProviderName();

    }

    @Override

    public DynClass getDynClass() {

        return this.metadata.getDynClass();

    }

    @Override

    public void implement(DynClass dynClass) {

        this.metadata.implement(dynClass);

    }

    @Override

    public void delegate(DynObject dynObject) {

        this.metadata.delegate(dynObject);

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if (this.metadata.hasDynValue(name)) {

            return this.metadata.getDynValue(name);

        }

        if (METADATA_PROVIDER.equalsIgnoreCase(name)) {

            return this.provider.getProviderName();

        } else if (METADATA_CONTAINERNAME.equalsIgnoreCase(name)) {

            return this.provider.getSourceId();

        }

        return this.metadata.getDynValue(name);

    }

    @Override

    public void setDynValue(String name, Object value) throws DynFieldNotFoundException {

        this.metadata.setDynValue(name, value);

    }

    @Override

    public boolean hasDynValue(String name) {

        return this.metadata.hasDynValue(name);

    }

    @Override

    public Object invokeDynMethod(String name, Object[] args) throws DynMethodException {

        return this.metadata.invokeDynMethod(this, name, args);

    }

    @Override

    public Object invokeDynMethod(int code, Object[] args) throws DynMethodException {

        return this.metadata.invokeDynMethod(this, code, args);

    }

    @Override

    public void clear() {

        if (metadata != null) {

            metadata.clear();

        }

    }

    @Override

    public RasterQuery createRasterQuery() {

        return new DefaultRasterQuery();

    }

    @Override

    public DataStore getStore() {

        return this;

    }

    @Override

    public void update(Observable observable, Object notification) {

        if (observable instanceof DataSet) {

            this.notifyChange(RasterStoreNotification.DATASET_CHANGED);

        } else {

            if (observable instanceof RasterStoreProvider) {

                if (observable == this.provider) {

                    this.notifyChange(RasterStoreNotification.STORE_PROVIDER_CHANGED);

                }

            }

        }

    }

    @Override

    protected void doDispose() throws BaseException {

        LOGGER.debug("Dispose DefaultRasterStore '"+this.getFullName()+"'");

        this.notifyChange(DataStoreNotification.BEFORE_DISPOSE);

        DisposeUtils.dispose(this.provider);

        this.provider = null;

        this.parameters = null;

        if(additionalBands!=null){

          for (BandsFromStore bandsFromStore : additionalBands) {

            DisposeUtils.dispose(bandsFromStore);

          }

            this.additionalBands = null;

        }

        this.notifyChange(DataStoreNotification.AFTER_DISPOSE);

        if (delegateObservable != null) {

            this.delegateObservable.deleteObservers();

            this.delegateObservable = null;

        }

    }

    @Override

    public Object clone() throws CloneNotSupportedException {

        DataStoreParameters dsp = getParameters();

        DefaultRasterStore cloned_store = null;

        try {

            cloned_store = (DefaultRasterStore) DALLocator.getDataManager().openStore(this.getProviderName(), dsp);

            cloned_store.additionalBands = new ArrayList<>(additionalBands);

        } catch (Exception e) {

            throw new CloneException(e);

        }

        return cloned_store;

    }

    /**

     * Notifies change

     *

     * @param notification

     */

    public void notifyChange(String notification) {

        if (delegateObservable != null) {

            notifyChange(new DefaultRasterStoreNotification(this, notification));

        }

    }

    @Override

    public void notifyChange(String notification, ResourceProvider data) {

        notifyChange(new DefaultRasterStoreNotification(this, DataStoreNotification.RESOURCE_CHANGED));

    }

    /**

     * Notifies change

     *

     * @param storeNotification

     */

    public void notifyChange(DefaultRasterStoreNotification storeNotification) {

        try {

            delegateObservable.notifyObservers(storeNotification);

        } catch (Exception e) {

            LOGGER.warn("Problems notifying changes in store '"+getName()+"'.", e);

        }

    }

    /**

     * Gets this provider

     *

     * @return RasterStoreProvider

     */

    @Override

    public RasterStoreProvider getProvider() {

        return this.provider;

    }

    @Override

    public Envelope getEnvelope() throws DataException, LocatorException, CreateEnvelopeException {

        return getDimensions().getEnvelope();

    }

    @Override

    public List<BandDescriptor> getBandDescriptors() {

        List<BandDescriptor> bands = new ArrayList<>();

        for( int i=0; i<this.getBands(); i++ ) {

            bands.add(this.getBandDescriptor(i));

        }

        return bands;

    }

    @Override

    public BandDescriptor getBandDescriptor(int band) {

        int bandsCounter = this.provider.getBands();

        if(band<bandsCounter){

            return this.provider.getBandDescriptor(band);

        }

        if(additionalBands!=null){

            for (BandsFromStore bandsFromStore : additionalBands) {

                if((band-bandsCounter)<bandsFromStore.bands.size()){

                    return bandsFromStore.getBandDescriptor(band-bandsCounter);

                }

                bandsCounter+=bandsFromStore.size();

            }

        }

        return null;

    }

    @Override

    public BandQuery createBandQuery(int band) {

        return new DefaultBandQuery(band, getBandDescriptor(band));

    }

    @Override

    public int getBands() {

        int bands = this.provider.getBands();

        if(additionalBands!=null){

            for (BandsFromStore bandsFromStore : additionalBands) {

                bands+=bandsFromStore.size();

            }

        }

        return bands;

    }

    @Override

    public BandDescriptor createBandDescriptor(int band, List<BandAttributeDescriptor> attributes) {

        return new DefaultBandDescriptor(this, band, attributes);

    }

    @Override

    public BandAttributeDescriptor createBandAttributeDescriptor(int band, String name, String description,

        List<Object> values, String units) {

        return new DefaultBandAttributeDescriptor(band, name, description, values, units);

    }

    @Override

    public BandAttributeDescriptor createBandAttributeDescriptor(int band, String name, Object value, String description,

        List<Object> values, String units) {

        return new DefaultBandAttributeDescriptor(band, name, value, description, values, units);

    }

    @Override

    public BandAttributeDescriptor createBandAttributeDescriptor(int band, String name, String description,

        List<Object> values) {

        return new DefaultBandAttributeDescriptor(band, name, description, values);

    }

    @Override

    public void notifyChange(String notification, Resource resource) {

        notifyChange(new DefaultRasterStoreNotification(this, DataStoreNotification.RESOURCE_CHANGED));

    }

    @Override

    public RasterStore getRasterStore() {

        return this;

    }

    @Override

    public void useCache(String providerName, DynObject parameters) throws DataException {

        if (providerName == null) {

            throw new InitializeException("It is necessary to provide a cache name", null);

        }

        if (parameters == null) {

            throw new InitializeException("It is necessary to provide parameters to create the explorer", null);

        }

        DataManagerProviderServices manager = DALSPILocator.getDataManagerProviderServices();

        RasterStoreProviderFactory providerFactory =

            (RasterStoreProviderFactory) manager.getStoreProviderFactory(providerName);

        if (providerFactory == null) {

            throw new ProviderNotRegisteredException(providerName);

        }

        RasterCacheStoreProvider cache =

            (RasterCacheStoreProvider) providerFactory.createProvider((DataParameters) parameters, this);

        RasterQuery rasterQuery = this.createRasterQuery();

        cache.apply(provider,

            (IProjection) this.getParameters().getDynValue(DataStore.METADATA_CRS), rasterQuery);

        this.provider = cache;

    }

    @Override

    public RasterCache getCache() {

        if(this.provider instanceof RasterCache){

            return (RasterCache) this.provider;

        }

        return null;

    }

    @Override

    public void intialize(DataManager dataManager, DataStoreParameters parameters) throws InitializeException {

        DynObjectManager dynManager = ToolsLocator.getDynObjectManager();

        this.metadata =

            (DelegatedDynObject) dynManager.createDynObject(METADATA_DEFINITION_NAME,

                MetadataManager.METADATA_NAMESPACE);

        this.dataManager = (DefaultDataManager) dataManager;

        this.parameters = parameters;

    }

    @Override

    public void setProvider(org.gvsig.fmap.dal.DataStoreProvider provider) {

        if(this.provider != null){

            throw new IllegalStateException("Provider already set.");

        }

        this.provider = (RasterStoreProvider) provider;

        // FIXME: habr?a que hacer un bind del provider y a?adir un dispose en el openStore del DataManager

//        DisposeUtils.bind(this.provider);

        this.delegate(this.provider);

    }

    @Override

    public void addBand(RasterStore store, int band) throws DataException {

        if(store.equals(this)){

            LOGGER.warn("Can't add bands that belong to this same store.");

            throw new IllegalArgumentException("Can't add bands that belong to this same store.");

        }

        try {

            if(!store.getEnvelope().equals(this.getEnvelope())){

                LOGGER.warn("The envelopes are differents.");

                throw new AddingBandsException(store.getName(), this.getName(), "The envelopes are differents.", null);

            }

        } catch (LocatorException | DataException | CreateEnvelopeException e) {

            LOGGER.warn("Can't compare the envelopes.",e);

            throw new AddingBandsException(store.getName(), this.getName(), "Can't compare the envelopes.", e);

        }

        if(!store.getParameters().getDynValue(METADATA_CRS).equals(this.getParameters().getDynValue(METADATA_CRS))){

            throw new AddingBandsException(store.getName(), this.getName(), "The projections are differents.", null);

        }

        if(additionalBands==null){

            this.additionalBands = new ArrayList<>();

        }

        boolean found = false;

      for (BandsFromStore bandsFromStore : additionalBands) {

        if(bandsFromStore.getStore().equals(store)){

          found = true;

          if(bandsFromStore.contains(band)){

            LOGGER.warn("The band '"+band+"' of the store '"+store.getName()+"' is already added to the additional bands.");

          } else {

            bandsFromStore.add(band);

          }

          break;

        }

      }

        if(!found){

            BandsFromStore bandsFromStore = new BandsFromStore(store);

            bandsFromStore.add(band);

            this.additionalBands.add(bandsFromStore);

        }

    }

    @Override

    public void addBands(RasterStore store, List<Integer> bands) throws DataException {

        if(store.equals(this)){

            LOGGER.warn("Can't add bands that belong to this same store.");

            throw new IllegalArgumentException("Can't add bands that belong to this same store.");

        }

        try {

            if(!store.getEnvelope().equals(this.getEnvelope())){

                LOGGER.warn("The envelopes are differents.");

                throw new AddingBandsException(store.getName(), this.getName(), "The envelopes are differents.", null);

            }

        } catch (LocatorException | DataException | CreateEnvelopeException e) {

            LOGGER.warn("Can't compare the envelopes.",e);

            throw new AddingBandsException(store.getName(), this.getName(), "Can't compare the envelopes.", e);

        }

        if(!store.getParameters().getDynValue(METADATA_CRS).equals(this.getParameters().getDynValue(METADATA_CRS))){

            throw new AddingBandsException(store.getName(), this.getName(), "The projections are differents.", null);

        }

        if(additionalBands==null){

            this.additionalBands = new ArrayList<>();

        }

        boolean found = false;

        for (BandsFromStore bandsFromStore : additionalBands) {

            if(bandsFromStore.getStore().equals(store)){

                found = true;

              for (Integer band : bands) {

                bandsFromStore.add(band);

              }

            }

        }

        if(!found){

            BandsFromStore bandsFromStore = new BandsFromStore(store, bands);

            this.additionalBands.add(bandsFromStore);

        }

    }

    @Override

    public void clearAdditionalBands() {

        if (this.additionalBands != null) {

            for (BandsFromStore bandsFromStore : additionalBands) {

                DisposeUtils.dispose(bandsFromStore);

            }

        }

        this.additionalBands = null;

    }

    @Override

    public void removeBand(int band) {

        if(band<getProvider().getBands()){

            throw new IllegalArgumentException("Can't remove bands of main store.");

        }

        int bandCounter = getProvider().getBands();

        int storeCounter = 0;

        while(bandCounter < band){

            BandsFromStore additionalStore = this.additionalBands.get(storeCounter);

            if( (band-bandCounter) < additionalStore.size()){

                additionalStore.remove(band-bandCounter);

                if(additionalStore.size()==0){

                    DisposeUtils.disposeQuietly(additionalStore);

                    this.additionalBands.remove(additionalStore);

                }

                return;

            }

            bandCounter += additionalStore.size();

        }

    }

    private static class BandsFromStore extends AbstractDisposable{

        RasterStore store;

        List<Integer> bands;

        public BandsFromStore(RasterStore store){

            this.store = store;

            ToolsLocator.getDisposableManager().bind(store);

            this.bands = new ArrayList<>();

        }

        public BandsFromStore(RasterStore store, List<Integer> bands){

            this.store = store;

            ToolsLocator.getDisposableManager().bind(store);

            this.bands = bands;

        }

        /**

         * Add the band to the list

         *

         * @param band

         */

        public void add(int band){

            if(bands.contains(band)){

                throw new IllegalArgumentException("The band "+band+" is already added.");

            }

            this.bands.add(band);

        }

        /**

         * Remove the band from the list

         * @param band

         */

        public void remove(int band){

            if(!bands.contains(band)){

                throw new IllegalArgumentException("The band "+band+" isn't previously added.");

            }

            this.bands.remove(band);

        }

        public boolean contains(int band){

            return (bands.contains(band));

        }

        /**

         * Return the band from the store in the index position

         *

         * @param index

         * @return

         */

        public int get(int index){

            return this.bands.get(index);

        }

        public RasterStore getStore() {

            return store;

        }

        public int size() {

            return bands.size();

        }

        /**

         * Return the BandDescriptor of the band in the index position.

         * @param index

         * @return

         */

        public BandDescriptor getBandDescriptor(int index) {

            return store.getBandDescriptor(bands.get(index));

        }

        @Override

        protected void doDispose() throws BaseException {

            DisposeUtils.disposeQuietly(store);

        }

    }

    @Override

    public boolean isOwnBand(int band) {

        if(band < this.getProvider().getBands()){

            return true;

        }

        return false;

    }

    @Override

    public DataStoreProviderFactory getProviderFactory() {

        DataStoreProviderFactory factory = dataManager.getStoreProviderFactory(parameters.getDataStoreName());

        return factory;

    }

    @Override

    public BufferDimensions getDimensions() throws InitializeException {

        return this.getProvider().getDimensions();

    }

    @Override

    public boolean isTiled() {

        return this.provider.isTiled();

    }

    @Override

    public boolean hasDynMethod(String name) {

        return ((DynObject_v2)this.metadata).hasDynMethod(name);

    }

    @Override

    public StoresRepository getStoresRepository() {

        final StoresRepository mainRepository = this.dataManager.getStoresRepository();

        StoresRepository localRepository = this.provider.getStoresRepository();

        if( localRepository==null ) {

            return mainRepository;

        }

        StoresRepository repository = new BaseStoresRepository(this.getName());

        repository.addRepository(localRepository);

        repository.addRepository(mainRepository);

        return repository;

    }

    @Override

    public ResourcesStorage getResourcesStorage() {

        ResourcesStorage resourcesStorage;

        try {

            resourcesStorage = this.provider.getResourcesStorage();

            if( resourcesStorage!=null ) {

                return resourcesStorage;

            }

        } catch(Throwable th) {

        }

        try {

            DataServerExplorer explorer = this.getExplorer();

            if( explorer==null ) {

                return null;

            }

            return this.getExplorer().getResourcesStorage(this);

        } catch (Exception ex) {

            LOGGER.warn("Can't create resources storage",ex);

            return null;

        }

    }

}