Application: gvSIG desktop

import org.gvsig.tools.util.LabeledValue;

public interface DataServerExplorerPoolEntry extends Persistent, LabeledValue<DataServerExplorerPoolEntry> {

  public void addAggregate(String funcName, String columnName);

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.fmap.dal.spi;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataServerExplorerPoolEntry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 *

 * @author gvSIG Team

 */

public class DataServerExplorerPoolEntryImpl implements DataServerExplorerPoolEntry {

    private static final String PERSISTENCE_DEFINITION_NAME = "DataServerExplorerPoolEntry";

    protected String name;

    protected String description;

    protected DataServerExplorerParameters explorer;

    public DataServerExplorerPoolEntryImpl() {

        // Required by Persistent 

    }

    public DataServerExplorerPoolEntryImpl(String name, String description, DataServerExplorerParameters explorer) {

        this.name = name;

        this.description = description;

        this.explorer = explorer;

    }

    @Override

    public String getName() {

        return this.name;

    }

    @Override

    public void copyTo(DataServerExplorerPoolEntry target) {

        DataServerExplorerPoolEntryImpl other = (DataServerExplorerPoolEntryImpl)target;

        other.name = this.name;

        other.description = this.description;

        other.explorer = this.explorer;                 

    }

    @Override

    public DataServerExplorerParameters getExplorerParameters() {

        return this.explorer;

    }

    @Override

    public String getDescription() {

        return this.description;

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("name", this.name);

        state.set("description", this.description);

        state.set("explorer", this.explorer);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        this.description = state.getString("description");

        this.name = state.getString("name");

        this.explorer = (DataServerExplorerParameters) state.get("explorer");

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if ( manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null ) {

            DynStruct definition

                    = manager.addDefinition(DataServerExplorerPoolEntryImpl.class,

                            PERSISTENCE_DEFINITION_NAME, PERSISTENCE_DEFINITION_NAME

                            + " Persistent definition", null, null);

            definition.addDynFieldString("name")

                    .setMandatory(true)

                    .setPersistent(true);

            definition.addDynFieldString("description")

                    .setMandatory(false)

                    .setPersistent(true);

            definition.addDynFieldObject("explorer")

                    .setClassOfValue(DataServerExplorerParameters.class)

                    .setMandatory(true)

                    .setPersistent(true);

        }

    }

    @Override

    public String getLabel() {

        return this.getName();

    }

    @Override

    public DataServerExplorerPoolEntry getValue() {

        return this;

    }

}

package org.gvsig.fmap.dal.spi;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataServerExplorerPool;

import org.gvsig.fmap.dal.DataServerExplorerPoolEntry;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

public class DataServerExplorerPoolImpl implements DataServerExplorerPool {

    private static final String PERSISTENCE_DEFINITION_NAME = "DataServerExplorerPool";

    private List<DataServerExplorerPoolEntry> pool;

    public DataServerExplorerPoolImpl() {

        this.pool = new ArrayList();

    }

    @Override

    public boolean contains(String name) {

        DataServerExplorerPoolEntry entry = this.get(name);

        return entry!=null;

    }

    @Override

    public boolean contains(DataServerExplorerPoolEntry entry) {

        return contains(entry.getName());

    }

    @Override

    public boolean isEmpty() {

        return this.pool.isEmpty();

    }

    @Override

    public DataServerExplorerPoolEntry createEntry(String name, String description, DataServerExplorerParameters explorer) {

        DataServerExplorerPoolEntryImpl entry = new DataServerExplorerPoolEntryImpl(name, description, explorer);

        return entry;

    }

    @Override

    public void add(String name, DataServerExplorerParameters explorer) {

        this.add(name, null, explorer);

    }

    @Override

    public void add(String name, String description, DataServerExplorerParameters explorer) {

        DataServerExplorerPoolEntry newexplorer = createEntry(name, description, explorer);

        DataServerExplorerPoolEntry existent = this.get(name);

        if( existent!=null ) {

            newexplorer.copyTo(existent);

        } else {

            this.pool.add(newexplorer);

        }

    }

    @Override

    public void remove(DataServerExplorerPoolEntry entry) {

        this.remove(entry.getName());

    }

    @Override

    public void remove(int explorerIndex) {

        this.pool.remove(explorerIndex);

    }

    @Override

    public void remove(String name) {

        if( StringUtils.isBlank(name) ) {

            return;

        }

        for( int i=0; i<this.pool.size(); i++ ) {

            DataServerExplorerPoolEntry entry = (DataServerExplorerPoolEntry) this.pool.get(i);

            if( name.equalsIgnoreCase(entry.getName()) ) {

                this.remove(i);

            }

        }

    }

    @Override

    public int size() {

        return this.pool.size();

    }

    @Override

    public DataServerExplorerPoolEntry get(int index) {

        return (DataServerExplorerPoolEntry) this.pool.get(index);

    }

    @Override

    public DataServerExplorerPoolEntry get(String name) {

        if( StringUtils.isBlank(name) ) {

            return null;

        }

        for( int i=0; i<this.pool.size(); i++ ) {

            DataServerExplorerPoolEntry entry = (DataServerExplorerPoolEntry) this.pool.get(i);

            if( name.equalsIgnoreCase(entry.getName()) ) {

                return entry;

            }

        }

        return null;

    }

    @Override

    public Iterator iterator() {

        return this.pool.iterator();

    }

    @Override

    public void saveToState(PersistentState state) throws PersistenceException {

        state.set("pool", pool);

    }

    @Override

    public void loadFromState(PersistentState state) throws PersistenceException {

        List l = state.getList("pool");

        this.pool = new ArrayList();

        this.pool.addAll(l);

    }

    public static void registerPersistenceDefinition() {

        PersistenceManager manager = ToolsLocator.getPersistenceManager();

        if ( manager.getDefinition(PERSISTENCE_DEFINITION_NAME) == null ) {

            DynStruct definition

                    = manager.addDefinition(DataServerExplorerPoolImpl.class,

                            PERSISTENCE_DEFINITION_NAME, PERSISTENCE_DEFINITION_NAME

                            + " Persistent definition", null, null);

            definition.addDynFieldList("pool")

                    .setClassOfItems(DataServerExplorerPoolEntryImpl.class)

                    .setMandatory(true)

                    .setPersistent(true);

        }

    }

}

  public void addAggregate(String funcName, String columnName) {

        Map<String, String> aggregateds = this.getAggregateFunctions();

        aggregateds.put(columnName, funcName);

  }

  @Override

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

            this.dataServerExplorerPool = new DataServerExplorerPoolImpl();

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

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

        DataServerExplorerPoolImpl.registerPersistenceDefinition();

        DataServerExplorerPoolEntryImpl.registerPersistenceDefinition();

/*

 * 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.swing.featuretable;

import java.util.Iterator;

import java.util.List;

import javax.swing.JTable;

import javax.swing.table.TableModel;

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

import org.gvsig.tools.dispose.Disposable;

import org.gvsig.tools.util.UnmodifiableBasicList;

/**

 *

 * @author gvSIG Team

 */

public interface SimpleFeaturesTableModel extends TableModel, Disposable, UnmodifiableBasicList<Feature> {

    public List<Feature> getFeatures();

    public boolean hasErrors();

    public void setCellRenderers(JTable table);

}

package org.gvsig.fmap.dal.swing.impl.featuretable;

import org.gvsig.fmap.dal.swing.featuretable.SimpleFeaturesTableModel;

import java.math.BigDecimal;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import javax.swing.JTable;

import javax.swing.table.AbstractTableModel;

import javax.swing.table.DefaultTableCellRenderer;

import org.gvsig.fmap.dal.complements.Search;

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dataTypes.Coercion;

import org.gvsig.tools.dataTypes.CoercionException;

import org.gvsig.tools.dataTypes.DataTypes;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.logger.FilteredLogger;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public class SimpleFeaturesTableModelImpl

        extends AbstractTableModel

        implements SimpleFeaturesTableModel {

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

    private static class FeatureAttributeCellRenderer extends DefaultTableCellRenderer {

        private final FeatureAttributeDescriptor descriptor;

        private final Coercion toStr;

        public FeatureAttributeCellRenderer(FeatureAttributeDescriptor descriptor) {

            this.descriptor = descriptor;

            this.toStr = ToolsLocator.getDataTypesManager().get(DataTypes.STRING).getCoercion();

        }

        @Override

        protected void setValue(Object value) {

            if (value == null) {

                setText("");

            } else {

                try {

                    value = toStr.coerce(value);

                } catch (CoercionException ex) {

                    LOGGER.debug("Can't coerce value to string.", ex);

                }

                setText((String) value);

            }

        }

    }

    private List<Feature> features;

    private final List<String> columnNames;

    private final FeatureType featureType;

    private FilteredLogger logger;

    private boolean errors;

    public SimpleFeaturesTableModelImpl(FeatureStore store) throws DataException {

        this(store.getDefaultFeatureType(), null, store.getFeatures());

    }

    public SimpleFeaturesTableModelImpl(FeatureType featureType) {

        this(featureType, null, null);

        this.logger = new FilteredLogger(LOGGER, "SimpleFeaturesTableModel", 10);

    }

    public SimpleFeaturesTableModelImpl(FeatureType featureType, List<String> columnNames, List<Feature> features) {

        this.logger = new FilteredLogger(LOGGER, "SimpleFeaturesTableModel", 10);

        this.features = features;

        this.featureType = featureType;

        this.errors = false;

        if (columnNames == null || columnNames.isEmpty()) {

            this.columnNames = new ArrayList<>();

            Search search = (Search) ToolsLocator.getComplementsManager().get(

                    Search.COMPLEMENT_MANE, featureType

            );

            List<Search.OrderedAttribute> attributos = search.getOrderedAttributes(

                    Search.BASIC_TYPES_FILTER,

                    Search.STR_INT_LONG_LABEL_ORDER,

                    12

            );

            for (Search.OrderedAttribute attrdesc : attributos) {

                this.columnNames.add(attrdesc.getDescriptor().getName());

            }

        } else {

            this.columnNames = columnNames;

        }

    }

    public void setCellRenderers(JTable table) {

        if ( table.getModel() != this ) {

            return;

        }

        for (String columnName : this.columnNames) {

            try {

                FeatureAttributeDescriptor descriptor = this.featureType.getAttributeDescriptor(columnName);

                if (descriptor == null) {

                    descriptor = this.featureType.getExtraColumns().get(columnName);

                }

                switch (descriptor.getType()) {

                    case DataTypes.BYTEARRAY:

                        table.setDefaultRenderer(byte[].class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.DATE:

                        table.setDefaultRenderer(java.sql.Date.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.TIME:

                        table.setDefaultRenderer(java.sql.Time.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.TIMESTAMP:

                        table.setDefaultRenderer(java.util.Date.class, new FeatureAttributeCellRenderer(descriptor));

                        table.setDefaultRenderer(java.sql.Timestamp.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.FLOAT:

                        table.setDefaultRenderer(Float.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.DECIMAL:

                        table.setDefaultRenderer(BigDecimal.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                    case DataTypes.DOUBLE:

                        table.setDefaultRenderer(Double.class, new FeatureAttributeCellRenderer(descriptor));

                        break;

                }

            } catch (Exception ex) {

                throw new RuntimeException("Not able to get type of descriptor for column", ex);

            }

        }

    }

    @Override

    public List<Feature> getFeatures() {

        return this.features;

    }

    @Override

    public int getRowCount() {

        if (this.features == null) {

            return 0;

        }

        try {

            return this.features.size();

        } catch (Throwable ex) {

            this.errors = true;

            LOGGER.warn("Can't calculate row count.", ex);

            return 0;

        }

    }

    @Override

    public boolean hasErrors() {

        return this.errors;

    }

    @Override

    public int getColumnCount() {

        return this.columnNames.size();

    }

    @Override

    public String getColumnName(int columnIndex) {

        String attrName = this.columnNames.get(columnIndex);

        if (this.featureType == null) {

            return attrName;

        }

        FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

        if (attrdesc == null) {

            EditableFeatureAttributeDescriptor extraCol = this.featureType.getExtraColumns().get(attrName);

            if (extraCol != null) {

                return extraCol.getLocalizedShortLabel();

            }

            if (attrName == null) {

                return "Column" + columnIndex;

            }

            return attrName;

        }

        return attrdesc.getLocalizedShortLabel();

    }

    @Override

    public Class<?> getColumnClass(int columnIndex) {

        if (this.featureType == null) {

            return String.class;

        }

        try {

            String attrName = this.columnNames.get(columnIndex);

            FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

            if (attrdesc == null) {

                int extraIndex = featureType.getExtraColumns().getIndexOf(attrName);

                if (extraIndex != -1) {

                    attrdesc = featureType.getExtraColumns().get(extraIndex);

                }

            }

            if (attrdesc == null) {

                return String.class;

            }

            if (attrdesc.isForeingKey() && attrdesc.getForeingKey().isClosedList()) {

                return String.class;

            }

            Class theClass = attrdesc.getDataType().getDefaultClass();

            if (theClass == null) {

                return String.class;

            }

            return theClass;

        } catch (Exception ex) {

            return String.class;

        }

    }

    @Override

    public boolean isCellEditable(int rowIndex, int columnIndex) {

        return false;

    }

    @Override

    public Feature get(int position) {

        if (this.features == null) {

            return null;

        }

        Feature feature = this.features.get(position);

        return feature;

    }

    @Override

    public Object getValueAt(int rowIndex, int columnIndex) {

        if (this.features == null) {

            return null;

        }

        try {

            Feature feature = this.features.get(rowIndex);

            String attrName = this.columnNames.get(columnIndex);

            Object value = null;

            value = feature.get(attrName);

            FeatureAttributeDescriptor attrdesc = this.featureType.getAttributeDescriptor(attrName);

            if (attrdesc != null) {

                if (value == null) {

                    return null;

                }

                if (attrdesc.isForeingKey() && attrdesc.getForeingKey().isClosedList()) {

                    value = attrdesc.getForeingKey().getLabelForValue(value);

                }

            }

            return value;

        } catch (Throwable th) {

            this.errors = true;

            logger.warn("Can't get cell value at " + rowIndex + ", " + columnIndex + ".", th);

            return null;

        }

    }

    @Override

    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

    }

    @Override

    public List<Feature> toList() {

        return this.features;

    }

    @Override

    public boolean isEmpty() {

        return this.features.isEmpty();

    }

    @Override

    public int size() {

        return this.features.size();

    }

    @Override

    public Iterator<Feature> iterator() {

        return this.features.iterator();

    }

    @Override

    public void dispose() {

        if (this.features != null) {

            DisposeUtils.disposeQuietly(((FacadeOfAFeaturePagingHelper) features).getFeaturePagingHelper());

            this.features = null;

        }

        this.features = null;

    }

}

import org.gvsig.fmap.dal.swing.impl.featuretable.SimpleFeaturesTableModelImpl;

import org.gvsig.fmap.dal.swing.featuretable.SimpleFeaturesTableModel;

                    SimpleFeaturesTableModelImpl tableModel = new SimpleFeaturesTableModelImpl(

                        m.setCellRenderers(tblResults);

                        if (oldmodel instanceof SimpleFeaturesTableModelImpl) {

                            ((SimpleFeaturesTableModelImpl) oldmodel).dispose();

        SimpleFeaturesTableModelImpl emptyTableModel = new SimpleFeaturesTableModelImpl(

        SimpleFeaturesTableModelImpl model;

        model = new SimpleFeaturesTableModelImpl(

            List<Feature> features = ((SimpleFeaturesTableModelImpl) this.tblResults.getModel()).getFeatures();

import javax.swing.JTable;

import org.gvsig.fmap.dal.swing.impl.featuretable.SimpleFeaturesTableModelImpl;

            SimpleFeaturesTableModelImpl m = new SimpleFeaturesTableModelImpl(store);

        SimpleFeaturesTableModelImpl m = new SimpleFeaturesTableModelImpl(featureType, columnNames, features);