Application: gvSIG desktop

package org.gvsig.fmap.dal;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.Set;

import java.util.TreeSet;

import org.apache.commons.lang3.StringUtils;

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

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

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.observer.Notification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.gvsig.tools.util.CachedValue;

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;

    protected Map<String, CachedValue<FeatureType>> featureTypes;

    protected long featureTypeExpireTimeInMillis;

    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();

        this.featureTypeExpireTimeInMillis = 5*60*1000;

    }

    protected abstract DataStoreParameters getMyParameters(String name);

    protected abstract boolean isEmptyMyRepository();

    protected abstract int getMySize();

    protected abstract UnmodifiableBasicSet<String> getMyKeySet();

    protected FeatureType getMyFeatureType(String name) {

        if(this.featureTypes == null){

            this.featureTypes = new HashMap<>();

        }

        CachedValue<FeatureType> featureType = this.featureTypes.get(name.toLowerCase());

        if (featureType == null) {

            DataStoreParameters parameters = this.getMyParameters(name);

            if (parameters == null) {

                return null;

            }

            featureType = new CachedValue<FeatureType>(this.featureTypeExpireTimeInMillis){

                @Override

                protected void reload() {

                    DataStore store = null;

                    try {

                        store = DALLocator.getDataManager().openStore(

                                parameters.getDataStoreName(),

                                parameters,

                                false

                        );

                        if (!(store instanceof FeatureStore)) {

                            return;

                        }

                        this.setValue(((FeatureStore) store).getDefaultFeatureType());

                    } catch (Exception ex) {

                        throw new RuntimeException("Can't get feature type of '" + name + "'.", ex);

                    } finally {

                        DisposeUtils.disposeQuietly(store);

                    }

                }

            };

            this.featureTypes.put(name.toLowerCase(), featureType);

        }

        return featureType.get();

    }

    @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.isTheSameStore(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 FeatureType getFeatureType(String name) {

        FeatureType featureType = this.getMyFeatureType(name);

        if( featureType != null ) {

            return featureType;

        }

        for ( StoresRepository theRepository : this.subrepositories) {

            featureType = theRepository.getFeatureType(name);

            if( featureType != null ) {

                return featureType;

            }

        }

        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);

    }

    public Set<String> keySetDeep() {

        Set<String>keys = new TreeSet<>();

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

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

            for (String key : localkeys) {

                keys.add(key);

            }

        }

        for (StoresRepository theRepository : this.subrepositories) {

            if( theRepository!=null ) {

                UnmodifiableBasicSet<String> subrepokeys = theRepository.keySet();

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

                    for (String key : subrepokeys) {

                        keys.add(key);

                    }

                }

                keys.add(theRepository.getID());

            }

        }

        return keys;

    }

    public Set<String> keySetShallow() {

        Set<String>keys = new TreeSet<>();

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

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

            for (String key : localkeys) {

                keys.add(key);

            }

        }

        for (StoresRepository theRepository : this.subrepositories) {

            if( theRepository!=null ) {

                keys.add(theRepository.getID());

            }

        }

        return keys;

    }

}