gvSIG projects pool

/*

 * 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.vcsgis.lib.workspace;

import java.util.Iterator;

import java.util.List;

import java.util.function.Predicate;

import javax.swing.event.ChangeListener;

import org.gvsig.expressionevaluator.ExpressionBuilder;

import org.gvsig.expressionevaluator.ExpressionUtils;

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

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

import org.gvsig.fmap.dal.feature.paging.FeaturePagingHelper;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.swing.api.ChangeListenerHelper;

import org.gvsig.tools.swing.api.ToolsSwingLocator;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.util.GetItemWithSize64;

import org.gvsig.vcsgis.lib.VCSGisChange;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import static org.gvsig.vcsgis.lib.workspace.tables.WorkspaceChangesTable.COD_ENTITY;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 * @param <CHANGE>

 */

@SuppressWarnings("UseSpecificCatch")

public abstract class ChangesImpl<CHANGE extends VCSGisChange> implements VCSGisWorkspaceChanges<CHANGE> {

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

    final FeaturePagingHelper changes;

    ChangeListenerHelper changeListernerHelper; 

    private final String selectedFieldName;

    public ChangesImpl(GetItemWithSize64<Feature> changes, String selectedFieldName) {

        this.changes = (FeaturePagingHelper) changes;

        this.changeListernerHelper = ToolsSwingLocator.getToolsSwingManager().createChangeListenerHelper();

        this.selectedFieldName = selectedFieldName;

    }

    abstract protected CHANGE createChange(Feature f);

    abstract protected void updateChange(FeatureStore store, CHANGE change);

    @Override

    public void addSelectionInterval(long start, long end) {

        try {

            FeatureStore store = this.changes.getFeatureStore();

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            for (long i = start; i <= end; i++) {

                Feature feat = this.changes.getFeatureAt(i);

                CHANGE row = this.createChange(feat);

                row.setSelected(true);

                updateChange(store, row);

            }

            store.finishEditingQuietly();

            this.changes.reload();

            this.fireChanges();

        } catch (Exception ex) {

            LOGGER.warn("Can't add to selection.", ex);

        }

    }

    @Override

    public void removeSelectionInterval(long start, long end) {

        try {

            FeatureStore store = this.changes.getFeatureStore();

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            for (long i = start; i <= end; i++) {

                Feature feat = this.changes.getFeatureAt(i);

                CHANGE row = this.createChange(feat);

                row.setSelected(false);

                updateChange(store, row);

            }

            store.finishEditingQuietly();

            this.changes.reload();

            this.fireChanges();

        } catch (Exception ex) {

            LOGGER.warn("Can't add to selection.", ex);

        }

    }

    @Override

    public void setSelectionInterval(long start, long end) {

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager()

                .createDefaultSimpleTaskStatus("_Select_interval_changes");

        status.setAutoremove(true);

        status.add();

        try {

            status.setRangeOfValues(start, end);

            status.message("_Updating_selection");

            FeatureStore store = this.changes.getFeatureStore();

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            store.update(this.selectedFieldName, false);

            for (long i = start; i <= end; i++) {

                Feature feat = this.changes.getFeatureAt(i);

                CHANGE row = this.createChange(feat);

                row.setSelected(true);

                updateChange(store, row);

                status.setCurValue(i);

            }

            status.message("_Finising_process");

            store.finishEditingQuietly();

            status.message("_Reloading_changes");

            this.changes.reload();

            status.message("_Refresing");

            this.fireChanges();

            status.terminate();

        } catch (Exception ex) {

            LOGGER.warn("Can't process.", ex);

            status.message("Can't process changes ("+ex.getMessage()+")");

            status.abort();

        }

    }

    @Override

    public void clearSelection() {

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager()

                .createDefaultSimpleTaskStatus("_Clear_changes_selection");

        status.setAutoremove(true);

        status.add();

        try {

            status.setIndeterminate();

            status.message("_Updating_selection");

            FeatureStore store = this.changes.getFeatureStore();

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            store.update(this.selectedFieldName, false);

            status.message("_Finising_process");

            store.finishEditingQuietly();

            status.message("_Reloading_changes");

            this.changes.reload();

            status.message("_Refresing");

            this.fireChanges();

            status.terminate();

        } catch (Exception ex) {

            LOGGER.warn("Can't process.", ex);

            status.message("Can't process changes ("+ex.getMessage()+")");

            status.abort();

        }

    }

    @Override

    public void setSelectionAll() {

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager()

                .createDefaultSimpleTaskStatus("_Selecting_all_changes");

        status.setAutoremove(true);

        status.add();

        try {

            status.setIndeterminate();

            status.message("_Updating_selection");

            FeatureStore store = this.changes.getFeatureStore();

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            store.update(this.selectedFieldName, true);

            status.message("_Finising_process");

            store.finishEditingQuietly();

            status.message("_Reloading_changes");

            this.changes.reload();

            status.message("_Refresing");

            this.fireChanges();

            status.terminate();

        } catch (Exception ex) {

            LOGGER.warn("Can't process.", ex);

            status.message("Can't process changes ("+ex.getMessage()+")");

            status.abort();

        }

    }

    @Override

    public void process(Iterator<Long> rows, Predicate<CHANGE> action) {

        SimpleTaskStatus status = ToolsLocator.getTaskStatusManager()

                .createDefaultSimpleTaskStatus("_Processing_changes");

        status.setAutoremove(true);

        status.add();

        try {

            status.setRangeOfValues(0, this.size64());

            status.message("_Processing");

            FeatureStore store = this.changes.getFeatureStore();

            store.edit(FeatureStore.MODE_PASS_THROUGH);

            while(rows.hasNext()){

                Long row = rows.next();

                Feature feat = this.changes.getFeatureAt(row);

                CHANGE change = this.createChange(feat);

                if(action.test(change)){

                    updateChange(store, change);

                }

                status.incrementCurrentValue();

            }

            status.message("_Finising_process");

            store.finishEditingQuietly();

            status.message("_Reloading_changes");

            this.changes.reload();

            status.message("_Refresing");

            this.fireChanges();

            status.terminate();

        } catch (Exception ex) {

            LOGGER.warn("Can't process.", ex);

            status.message("Can't process changes ("+ex.getMessage()+")");

            status.abort();

        }

    }

    @Override

    public boolean isSelectedIndex(long index) {

        try {

            Feature feat = this.changes.getFeatureAt(index);

            return feat.getBoolean(this.selectedFieldName);

        } catch (BaseException ex) {

            LOGGER.warn("Can't check if is selected.", ex);

            throw new RuntimeException("Can't check if is selected.", ex);

        }

    }

    @Override

    public boolean isSelectionEmpty() {

        try {

            FeatureStore store = this.changes.getFeatureStore();

            Feature foundFeat = store.findFirst("\""+this.selectedFieldName+"\"");

            return foundFeat == null;

        } catch (BaseException ex) {

            LOGGER.warn("Can't check if is empty selection.", ex);

            throw new RuntimeException("Can't check if is selected.", ex);

        }

    }

    @Override

    public boolean isSelectionFromEntitiesEmpty(List<VCSGisEntity> entities) {

        try {

            if(entities.isEmpty()){

                return false;

            }

            ExpressionBuilder expBuilder = ExpressionUtils.createExpressionBuilder();

            for (VCSGisEntity entity : entities) {

                if(entity != null){

                    expBuilder.or(

                            expBuilder.eq(

                                expBuilder.column(COD_ENTITY),

                                expBuilder.constant(entity.getEntityCode())

                            )

                    );

                }

            }

            ExpressionBuilder.Value or = expBuilder.value();

            expBuilder.set(null);

            expBuilder.and(expBuilder.column(this.selectedFieldName));

            expBuilder.and(expBuilder.group(or));

            FeatureStore store = this.changes.getFeatureStore();

            Feature foundFeat = store.findFirst(expBuilder.toString());

            return foundFeat == null;

        } catch (BaseException ex) {

            LOGGER.warn("Can't check if is empty selection.", ex);

            throw new RuntimeException("Can't check if is selected.", ex);

        }

    }

    @Override

    public long size64() {

        return changes.size64();

    }

    @Override

    public CHANGE get64(long position) {

        Feature f = changes.get64(position);

        if (f == null) {

            return null;

        }

        return (CHANGE) this.createChange(f);

    }

    private void fireChanges() {

        changeListernerHelper.fireEvent();

    }

    @Override

    public void addChangeListener(ChangeListener listener) {

        changeListernerHelper.addChangeListener(listener);

    }

    @Override

    public ChangeListener[] getChangeListeners() {

        return changeListernerHelper.getChangeListeners();

    }

    @Override

    public void removeChangeListener(ChangeListener listener) {

        changeListernerHelper.removeChangeListener(listener);

    }

    @Override

    public void removeAllChangeListener() {

        changeListernerHelper.removeAllChangeListener();

    }

    @Override

    public boolean hasChangeListeners() {

        return changeListernerHelper.hasChangeListeners();

    }

}