Application: gvSIG desktop

package org.gvsig.fmap.dal;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.util.PropertiesSupport;

import org.gvsig.tools.util.PropertiesSupportHelper;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.gvsig.tools.util.UnmodifiableBasicSetChained;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractStoresRepository  implements StoresRepository {

    protected final Logger LOGGER = LoggerFactory.getLogger(AbstractStoresRepository.class);

    private final String name;

    private final String label;

    private final List<StoresRepository> subrepositories;

    private final ObservableHelper observableHelper;

    private final PropertiesSupportHelper propertiesHelper;

    public AbstractStoresRepository(String name) {

        this(name, null);

    }

    public AbstractStoresRepository(String name, String label) {

        this.name = name;

        this.label = label;

        this.subrepositories = new ArrayList<>();

        this.observableHelper = new ObservableHelper();

        this.propertiesHelper = new PropertiesSupportHelper();

    }

    protected abstract DataStoreParameters getMyParameters(String name);

    protected abstract boolean isEmptyMyRepository();

    protected abstract int getMySize();

    protected abstract UnmodifiableBasicSet<String> getMyKeySet();

    @Override

    public void addObserver(Observer o) {

        this.observableHelper.addObserver(o);

    }

    @Override

    public void deleteObserver(Observer o) {

        this.observableHelper.deleteObserver(o);

    }

    @Override

    public void deleteObservers() {

        this.observableHelper.deleteObservers();

    }

    protected Notification notifyObservers(String notificationType, Object value) {

        return this.observableHelper.notifyObservers(this, notificationType, value);

    }

    protected Notification notifyObservers(String notificationType, Object value1, Object value2) {

        return this.observableHelper.notifyObservers(this, notificationType, value1, value2);

    }

    @Override

    public void add(String name, DataStoreParameters parameters) {

        throw new UnsupportedOperationException();

    }

    @Override

    public void add(String name, FeatureStore store) {

        add(name, store.getParameters());

    }

    @Override

    public void remove(String name) {

        throw new UnsupportedOperationException();

    }

    @Override

    public boolean contains(DataStoreParameters parameters) {

        for (DataStoreParameters currentParameters : this) {

            if( parameters.equals(currentParameters) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public String getID() {

        return this.name;

    }

    @Override

    public String getLabel() {

        if( StringUtils.isBlank(this.label) ) {

            return this.getID();

        }

        return this.label;

    }

    @Override

    public Collection<StoresRepository> getSubrepositories() {

        return this.subrepositories;

    }

    @Override

    public StoresRepository getSubrepository(String Id) {

        for (StoresRepository repo : this.subrepositories) {

            if( repo!=null && StringUtils.equalsIgnoreCase(Id, repo.getID()) ) {

                return repo;

            }

        }

        return null;

    }

    @Override

    public boolean addRepository(StoresRepository repository) {

        if( this.notifyObservers(NOTIFICATION_ADDREPOSITORY, repository).isCanceled() ) {

            return false;

        }

        this.removeRepository(repository.getID());

        this.subrepositories.add(repository);

        return true;

    }

    @Override

    public boolean removeRepository(String name) {

        if( this.notifyObservers(NOTIFICATION_REMOVEREPOSITORY, name).isCanceled() ) {

            return false;

        }

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

            StoresRepository repo = subrepositories.get(i);

            if( StringUtils.equalsIgnoreCase(name, repo.getID()) ) {

                this.subrepositories.remove(i);

                return true;

            }

        }

        return false;

    }

    @Override

    public DataStoreParameters get(String name) {

        DataStoreParameters parameters = this.getMyParameters(name);

        if( parameters!=null ) {

            return parameters;

        }

        for ( StoresRepository theRepository : this.subrepositories) {

            parameters = theRepository.get(name);

            if( parameters!=null ) {

                return parameters;

            }

        }

        return null;

    }

     public PropertiesSupport getProperties(String name) {

         return new PropertiesSupport() {

             @Override

             public Object getProperty(String name) {

                 return null;

             }

             @Override

             public void setProperty(String name, Object value) {

             }

             @Override

             public Map<String, Object> getProperties() {

                 return Collections.EMPTY_MAP;

             }

         };

     }

    @Override

    public DataStore getStore(String name) {

        PropertiesSupport properties = this.getProperties(name);

        if(properties!=null && 

                StringUtils.equalsIgnoreCase(Objects.toString(properties.getProperty("ignoreDALResource")),"true")) {

            return this.getStore(name, true);

        }

        return this.getStore(name, false);

    }

    public DataStore getStore(String name, boolean ignoreDALResource) {

        DataStoreParameters parameters = this.getMyParameters(name);

        if( parameters!=null ) {

            try {

                DataStore store = DALLocator.getDataManager().openStore(

                        parameters.getDataStoreName(), 

                        parameters,

                        ignoreDALResource

                );

                return store;

            } catch (Exception ex) {

                throw new RuntimeException("Can't open store '"+name+"'.", ex);

            }

        }

        for ( StoresRepository theRepository : this.subrepositories) {

            DataStore store = theRepository.getStore(name);

            if( store!=null ) {

                return store;

            }

        }

        return null;

    }

    @Override

    public boolean containsKey(String key) {

        DataStoreParameters parameters = this.getMyParameters(name);

        if( parameters!=null ) {

            return true;

        }

        for ( StoresRepository theRepository : this.subrepositories) {

            if( theRepository.containsKey(key) ) {

                return true;

            }

        }

        return false;

    }

    @Override

    public UnmodifiableBasicSet<String> keySet() {

        List<UnmodifiableBasicSet<String>> sets = new ArrayList<>();

        UnmodifiableBasicSet<String> keyset = this.getMyKeySet();

        if( keyset!=null && !keyset.isEmpty() ) {

            sets.add(keyset);

        }

        for (StoresRepository theRepository : this.subrepositories) {

            if( theRepository!=null ) {

                keyset = theRepository.keySet();

                if( keyset!=null && !keyset.isEmpty() ) {

                    sets.add(keyset);

                }

            }

        }

        if( sets.isEmpty() ) {

            return UnmodifiableBasicSet.EMPTY_UNMODIFIABLEBASICSET;

        }

        if( sets.size()==1 ) {

            return sets.get(0);

        }

        return new UnmodifiableBasicSetChained(

            sets.toArray(

                new UnmodifiableBasicSet[sets.size()]

            )

        );

    }

    @Override

    public Map<String, DataStoreParameters> toMap() {

        throw new UnsupportedOperationException();

    }

    @Override

    public boolean isEmpty() {

        if( !this.isEmptyMyRepository() ) {

            return false;

        }

        for ( StoresRepository theRepository : this.subrepositories) {

            if( !theRepository.isEmpty() ) {

                return false;

            }

        }

        return true;

    }

    @Override

    public int size() {

        int sz = 0;

        if( !this.isEmptyMyRepository() ) {

            sz = this.getMySize();

        }

        for ( StoresRepository theRepository : this.subrepositories) {

            sz += theRepository.size();

        }

        return sz;

    }

    @Override

    public Iterator<DataStoreParameters> iterator() {

        final Iterator<String> it = this.keySet().iterator();

        return new Iterator<DataStoreParameters>() {

            @Override

            public boolean hasNext() {

                return it.hasNext();

            }

            @Override

            public DataStoreParameters next() {

                String name = it.next();

                return get(name);

            }

        };

    }

    @Override

    public Map<String, Object> getProperties() {

        return this.propertiesHelper.getProperties();

    }

    @Override

    public Object getProperty(String name) {

        return this.propertiesHelper.getProperty(name);

    }

    @Override

    public void setProperty(String name, Object value) {

        this.propertiesHelper.setProperty(name, value);

    }

}