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.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

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;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultTransaction implements DataTransactionServices {

    private final String code;

    private final Set<DataServerExplorer> explorers;

    private final Map<String,ConnectionService> connections;

    private Set<DataStore> stores;

    private boolean inProgress;

    private List<Disposable> disposables;

    public DefaultTransaction() {

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

        this.stores = new HashSet<>();

        this.explorers = new HashSet<>();

        this.disposables = new ArrayList<>();

        this.inProgress = false;

        this.connections = new HashMap<>();

    }

    @Override

    public String getCode() {

        return this.code;

    }

    @Override

    public void begin() throws DataException {

        if( this.inProgress ) {

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

        }

        this.inProgress = true;

    }

    @Override

    public void commit() throws DataException {

        if( !this.isInProgress() ) {

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

        }

        for (DataStore store : stores) {

            if( store instanceof FeatureStore ) {

                FeatureStore fstore = (FeatureStore) store;

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

                    fstore.finishEditing();

                }

            }

        }

        this.inProgress = false;

    }

    @Override

    public void rollback() throws DataException {

        if( !this.isInProgress() ) {

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

        }

        for (DataStore store : stores) {

            if( store instanceof FeatureStore ) {

                FeatureStore fstore = (FeatureStore) store;

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

                    fstore.cancelEditing();

                }

            }

        }

        this.inProgress = false;

    }

    @Override

    public void rollbackQuietly() {

        try {

            this.rollback();

        } catch(Exception ex) {

            // Do nothing

        }

    }

    @Override

    public void add(DataStore store) {

        add(store, true);

    }

    @Override

    public void add(DataStore store, boolean local) {

        if(this.stores.contains(store)){

            return;

        }

        if( store instanceof SupportTransactions ) {

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

        }

        if(!local){

            DisposeUtils.bind(store);

        }

        this.stores.add(store);

    }

    @Override

    public void add(DataServerExplorer explorer) {

        add(explorer, true);

    }

    @Override

    public void add(DataServerExplorer explorer, boolean local) {

        if(this.explorers.contains(explorer)){

            return;

        }

        if( explorer instanceof SupportTransactions ) {

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

        }

        if(!local){

            DisposeUtils.bind(explorer);

        }

        this.explorers.add(explorer);

    }

    @Override

    public void add(Disposable resource) throws DataException {

        this.disposables.add(resource);

    }

    @Override

    public void remove(DataStore store) {

        if( this.inProgress ) {

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

        }

        if( store instanceof SupportTransactions ) {

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

        }

        this.stores.remove(store);

        DisposeUtils.dispose(store);

    }

    @Override

    public boolean isInProgress() {

        return inProgress;

    }

    @Override

    public void dispose() {

        if( this.inProgress ) {

            this.rollbackQuietly();

        }

        for (DataStore store : stores) {

            if( store instanceof SupportTransactions ) {

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

            }

            DisposeUtils.disposeQuietly(store);

        }

        for (DataServerExplorer explorer : explorers) {

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

        }

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

    }

}