Application: gvSIG desktop

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 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 3

 * 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, see <https://www.gnu.org/licenses/>. 

 * 

 * 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.impl;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.UUID;

import org.apache.commons.lang3.StringUtils;

import org.apache.commons.lang3.tuple.MutablePair;

import org.apache.commons.lang3.tuple.Pair;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.SupportTransactions;

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

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

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

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

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.dispose.DisposeUtils;

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

import org.gvsig.tools.observer.BaseNotification;

import org.gvsig.tools.observer.ObservableHelper;

import org.gvsig.tools.observer.Observer;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultTransaction extends AbstractDisposable implements DataTransactionServices {

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

    private final String code;

    private final Map<String,DataServerExplorer> explorers;

    private final Map<String,ConnectionService> connections;

    private Map<String,Pair<DataStore,Boolean>> stores;

    private boolean inProgress;

    private List<Disposable> disposables;

    private ObservableHelper observableHelper;

    public DefaultTransaction() {

        this.code = UUID.randomUUID().toString().replace("-", "");

        this.stores = new HashMap<>();

        this.explorers = new HashMap<>();

        this.disposables = new ArrayList<>();

        this.inProgress = false;

        this.connections = new HashMap<>();

        this.observableHelper = new ObservableHelper();

    }

    @Override

    public String getCode() {

        return this.code;

    }

    @Override

    public void begin() throws DataException {

        if( this.inProgress ) {

            throw new IllegalStateException("Transaction already started.");

        }

        this.observableHelper.notifyObservers(this, new BaseNotification("BEGIN", null));

        this.inProgress = true;

    }

    @Override

    public void commit() throws DataException {

        if( !this.isInProgress() ) {

            throw new IllegalStateException("Can't commit transaction without begin.");

        }

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore store = item.getLeft();

            if( store instanceof FeatureStore ) {

                FeatureStore fstore = (FeatureStore) store;

                if( fstore!=null && fstore.getMode() != MODE_QUERY) {

//                    LOGGER.info("Transaction commit: finishEditing "+store.getFullName());

                    fstore.finishEditing();

                }

            }

        }

        for (ConnectionService connection : this.connections.values()) {

            connection.finish();

        }

        this.observableHelper.notifyObservers(this, new BaseNotification("COMMIT", null));

        this.inProgress = false;

    }

    @Override

    public void rollback() throws DataException {

        if( !this.isInProgress() ) {

            throw new IllegalStateException("Can't rollback transaction without begin.");

        }

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore store = item.getLeft();

            if( store instanceof FeatureStore ) {

                FeatureStore fstore = (FeatureStore) store;

                if( fstore.getMode() != MODE_QUERY) {

                    fstore.cancelEditing();

                }

            }

        }

        for (ConnectionService connection : this.connections.values()) {

            connection.abort();

        }

        this.observableHelper.notifyObservers(this, new BaseNotification("ROLLBACK", null));

        this.inProgress = false;

    }

    @Override

    public void rollbackQuietly() {

        try {

            this.rollback();

        } catch(Exception ex) {

            // Do nothing

        }

    }

    @Override

    public void add(DataStore store) {

        add(store, null, true);

    }

    @Override

    public void add(DataStore store, String id) { 

        this.add(store, id, true);

    }

    @Override

    public void add(DataStore store, boolean local) {

        this.add(store, null, local);

    }

    @Override

    public void add(DataStore store, String id, boolean local) {

        String theId = id;

        if( StringUtils.isBlank(id) ) {

            theId = store.hashCode() + "@"+ store.getFullName();

        } else {

            DataStore theStore = this.stores.get(theId).getLeft();

            if(theStore!=null ){

                if( theStore==store ) {

                    return;

                }

                throw new IllegalArgumentException("The id '"+id+"' is already used.");

            }

        }

        if( store instanceof SupportTransactions ) {

            ((SupportTransactions) store).setTransaction(this);

        }

        if(!local){

            DisposeUtils.bind(store);

        }

        this.stores.put(theId,new MutablePair<>(store,local));

    }

    @Override

    public FeatureStore getFeatureStore(String id) {

        return (FeatureStore) this.stores.get(id);

    }

    @Override

    public void add(DataServerExplorer explorer) {

        this.add(explorer, null, true);

    }

    @Override

    public void add(DataServerExplorer explorer, String id) {

        this.add(explorer, id, true);

    }

    @Override

    public void add(DataServerExplorer explorer, boolean local) {

        this.add(explorer, null, local);

    }

    @Override

    public void add(DataServerExplorer explorer, String id, boolean local) {

        String theId = id;

        if( StringUtils.isBlank(id) ) {

            theId = String.valueOf(explorer.hashCode());

        } else {

            DataServerExplorer theExplorer = this.explorers.get(theId);

            if(theExplorer!=null ){

                if( theExplorer==explorer ) {

                    return;

                }

                throw new IllegalArgumentException("The id '"+id+"' is already used.");

            }

        }

        if( explorer instanceof SupportTransactions ) {

            ((SupportTransactions) explorer).setTransaction(this);

        }

        if(!local){

            DisposeUtils.bind(explorer);

        }

        this.explorers.put(theId,explorer);

    }

    @Override

    public DataServerExplorer getServerExplorer(String id) {

        return this.explorers.get(id);

    }

    @Override

    public void add(Disposable resource) throws DataException {

        this.disposables.add(resource);

    }

    @Override

    public void remove(DataStore store) {

        if( this.inProgress && !DisposeUtils.isNullOrDisposed(store)){

            throw new IllegalStateException("Can't remove store from a in progress transaction.");

        }

        String id = null;

        for (Map.Entry<String, Pair<DataStore,Boolean>> entry : this.stores.entrySet()) {

            if( store == entry.getValue().getLeft() ) {

                id = entry.getKey();

                break;

            }

        }

        if( id==null ) {

            return;

        }

        if( store instanceof SupportTransactions ) {

            ((SupportTransactions) store).setTransaction(null);

        }

        this.stores.remove(id);

        DisposeUtils.dispose(store);

    }

    @Override

    public void remove(DataServerExplorer serverExplorer) {

        if( this.inProgress ) {

            throw new IllegalStateException("Can't remove server explorer from a in progress transaction.");

        }

        String id = null;

        for (Map.Entry<String, DataServerExplorer> entry : this.explorers.entrySet()) {

            if( serverExplorer == entry.getValue() ) {

                id = entry.getKey();

                break;

            }

        }

        if( id==null ) {

            return;

        }

        if( serverExplorer instanceof SupportTransactions ) {

            ((SupportTransactions) serverExplorer).setTransaction(null);

        }

        this.explorers.remove(id);

        DisposeUtils.dispose(serverExplorer);

    }

    @Override

    public boolean isInProgress() {

        return inProgress;

    }

    @Override

    public void doDispose() {

        if( this.inProgress ) {

            this.rollbackQuietly();

        }

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore store = item.getLeft();

            if( store instanceof SupportTransactions ) {

                ((SupportTransactions) store).setTransaction(null);

            }

            DisposeUtils.disposeQuietly(store);

        }

        for (DataServerExplorer explorer : explorers.values()) {

            if( explorer instanceof SupportTransactions ) {

                ((SupportTransactions) explorer).setTransaction(null);

            }

            DisposeUtils.disposeQuietly(explorer);

        }

        for (Disposable resource : disposables) {

            if( resource instanceof SupportTransactions ) {

                ((SupportTransactions) resource).setTransaction(null);

            }

            DisposeUtils.disposeQuietly(resource);            

        }

        for (ConnectionService connection : this.connections.values()) {

            connection.dispose();

        }

        this.disposables = null;

        this.stores = null;

    }

    @Override

    public void close() throws Exception {

        this.dispose();

    }

    @Override

    public void addConnection(ConnectionService connection) {

        if( this.connections.containsKey(connection.getId()) ) {

            return;

        }

        this.connections.put(connection.getId(), connection);

    }

    @Override

    public ConnectionService getConnection(String id) {

        return this.connections.get(id);

    }

    @Override

    public void removeConnection(String id) {

        this.connections.remove(id);

    }

    @Override

    public boolean existsConnection(String id) {

        return this.connections.containsKey(id);

    }

    @Override

    public void addObserver(Observer obsrvr) {

        this.observableHelper.addObserver(obsrvr);

    }

    @Override

    public void deleteObserver(Observer obsrvr) {

        this.observableHelper.deleteObserver(obsrvr);

    }

    @Override

    public void deleteObservers() {

        this.observableHelper.deleteObservers();

    }

    @Override

    public boolean contains(DataServerExplorer explorer) {

        for (DataServerExplorer value : this.explorers.values()) {

            if(explorer == value){

                return true;

            }

        }

        return false;

    }

    @Override

    public boolean contains(DataStore store) {

        for (Pair<DataStore, Boolean> item : stores.values()) {

            DataStore value = item.getLeft();

            if(store == value){

                return true;

            }

        }

        return false;

    }

}