Application: gvSIG desktop

package org.gvsig.fmap.dal;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.tools.util.UnmodifiableBasicSet;

import org.gvsig.tools.util.UnmodifiableBasicSetChained;

/**

 *

 * @author jjdelcerro

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class AbstractStoresRepository  implements StoresRepository {

    private final String name;

    private final String label;

    private final List<StoresRepository> subrepositories;

    public AbstractStoresRepository(String name) {

        this(name, null);

    }

    public AbstractStoresRepository(String name, String label) {

        this.name = name;

        this.label = label;

        this.subrepositories = new ArrayList<>();

    }

    protected abstract DataStoreParameters getMyParameters(String name);

    protected abstract boolean isEmptyMyRepository();

    protected abstract int getMySize();

    protected abstract UnmodifiableBasicSet<String> getMyKeySet();

    @Override

    public void add(String name, DataStoreParameters parameters) {

        throw new UnsupportedOperationException();

    }

    @Override

    public void remove(String name) {

        throw new UnsupportedOperationException();

    }

    @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 boolean addRepository(StoresRepository repository) {

        this.removeRepository(repository.getID());

        this.subrepositories.add(repository);

        return true;

    }

    @Override

    public boolean removeRepository(String name) {

        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;

    }

    @Override

    public DataStore getStore(String name) {

        DataStoreParameters parameters = this.get(name);

        if( parameters!=null ) {

            try {

                DataStore store = DALLocator.getDataManager().openStore(

                        parameters.getDataStoreName(), 

                        parameters

                );

                return store;

            } catch (Exception ex) {

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

            }

        }

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

        sets.add(this.getMyKeySet());

        for (StoresRepository theRepository : this.subrepositories) {

            sets.add(theRepository.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);

            }

        };

    }

}